Collaboration diagram for PhpOffice\PhpSpreadsheet\Calculation\Calculation:

Public Member Functions
	__construct (?Spreadsheet $spreadsheet=null)

	flushInstance ()
	Flush the calculation cache for any existing instance of this class but only if a Calculation instance exists. More...

	getDebugLog ()
	Get the Logger for this calculation engine instance. More...

	__clone ()
	__clone implementation. More...

	getCalculationCacheEnabled ()
	Is calculation caching enabled? More...

	setCalculationCacheEnabled ($pValue)
	Enable/disable calculation cache. More...

	enableCalculationCache ()
	Enable calculation cache. More...

	disableCalculationCache ()
	Disable calculation cache. More...

	clearCalculationCache ()
	Clear calculation cache. More...

	clearCalculationCacheForWorksheet ($worksheetName)
	Clear calculation cache for a specified worksheet. More...

	renameCalculationCacheForWorksheet ($fromWorksheetName, $toWorksheetName)
	Rename calculation cache for a specified worksheet. More...

	setBranchPruningEnabled ($enabled)
	Enable/disable calculation cache. More...

	enableBranchPruning ()

	disableBranchPruning ()

	clearBranchStore ()

	getLocale ()
	Get the currently defined locale code. More...

	setLocale (string $locale)
	Set the locale code. More...

	_translateFormulaToLocale ($formula)

	_translateFormulaToEnglish ($formula)

	calculate (?Cell $pCell=null)
	Calculate cell value (using formula from a cell ID) Retained for backward compatibility. More...

	calculateCellValue (?Cell $pCell=null, $resetLog=true)
	Calculate the value of a cell formula. More...

	parseFormula ($formula)
	Validate and parse a formula string. More...

	calculateFormula ($formula, $cellID=null, ?Cell $pCell=null)
	Calculate the value of a formula. More...

	getValueFromCache (string $cellReference, &$cellValue)

	saveValueToCache ($cellReference, $cellValue)

	_calculateFormulaValue ($formula, $cellID=null, ?Cell $pCell=null)
	Parse a cell formula and calculate its value. More...

	extractCellRange (&$pRange='A1', ?Worksheet $pSheet=null, $resetLog=true)
	Extract range values. More...

	extractNamedRange (&$pRange='A1', ?Worksheet $pSheet=null, $resetLog=true)
	Extract range values. More...

	isImplemented ($pFunction)
	Is a specific function implemented? More...

	getFunctions ()
	Get a list of all implemented functions as an array of function objects. More...

	getImplementedFunctionNames ()
	Get a list of implemented Excel function names. More...

Static Public Member Functions
static	getInstance (?Spreadsheet $spreadsheet=null)
	Get an instance of this class. More...

static	getTRUE ()
	Return the locale-specific translation of TRUE. More...

static	getFALSE ()
	Return the locale-specific translation of FALSE. More...

static	setArrayReturnType ($returnType)
	Set the Array Return Type (Array or Value of first element in the array). More...

static	getArrayReturnType ()
	Return the Array Return Type (Array or Value of first element in the array). More...

static	translateSeparator ($fromSeparator, $toSeparator, $formula, &$inBraces)

static	localeFunc ($function)

static	wrapResult ($value)
	Wrap string values in quotes. More...

static	unwrapResult ($value)
	Remove quotes used as a wrapper to identify string values. More...

static	getMatrixDimensions (array &$matrix)
	Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0. More...

Data Fields
const	CALCULATION_REGEXP_NUMBER = '[-+]?\d*\.?\d+(e[-+]?\d+)?'
	Constants More...

const	CALCULATION_REGEXP_STRING = '"(?:[^"]\|"")*"'

const	CALCULATION_REGEXP_OPENBRACE = '\‍('

const	CALCULATION_REGEXP_FUNCTION = '@?(?:_xlfn\.)?([\p{L}][\p{L}\p{N}\.])[\s]\‍('

const	CALCULATION_REGEXP_CELLREF = '((([^\s,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?\$?\b([a-z]{1,3})\$?(\d{1,7})(?![\w.])'

const	CALCULATION_REGEXP_CELLREF_RELATIVE = '((([^\s\(,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?(\$?\b[a-z]{1,3})(\$?\d{1,7})(?![\w.])'

const	CALCULATION_REGEXP_COLUMN_RANGE = '(((([^\s\(,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?(\$?[a-z]{1,3})):(?![.*])'

const	CALCULATION_REGEXP_ROW_RANGE = '(((([^\s\(,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?(\$?[1-9][0-9]{0,6})):(?![.*])'

const	CALCULATION_REGEXP_COLUMNRANGE_RELATIVE = '(\$?[a-z]{1,3}):(\$?[a-z]{1,3})'

const	CALCULATION_REGEXP_ROWRANGE_RELATIVE = '(\$?\d{1,7}):(\$?\d{1,7})'

const	CALCULATION_REGEXP_DEFINEDNAME = '((([^\s,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?([_\p{L}][_\p{L}\p{N}\.]*)'

const	CALCULATION_REGEXP_ERROR = '\#[A-Z][A-Z0_\/]*[!\?]?'

const	RETURN_ARRAY_AS_ERROR = 'error'
	constants More...

const	RETURN_ARRAY_AS_VALUE = 'value'

const	RETURN_ARRAY_AS_ARRAY = 'array'

const	FORMULA_OPEN_FUNCTION_BRACE = '{'

const	FORMULA_CLOSE_FUNCTION_BRACE = '}'

const	FORMULA_STRING_QUOTE = '"'

	$suppressFormulaErrors = false

	$formulaError

	$cyclicFormulaCount = 1

Static Public Attributes
static	$localeBoolean

Protected Member Functions
	raiseFormulaError ($errorMessage)

Private Member Functions
	getLocaleFile (string $localeDir, string $locale, string $language, string $file)

	showValue ($value)
	Format details of an operand for display in the log (based on operand type). More...

	showTypeDetails ($value)
	Format type and details of an operand for display in the log (based on operand type). More...

	convertMatrixReferences ($formula)

	internalParseFormula ($formula, ?Cell $pCell=null)

	processTokenStack ($tokens, $cellID=null, ?Cell $pCell=null)

	validateBinaryOperand (&$operand, &$stack)

	executeArrayComparison ($cellID, $operand1, $operand2, $operation, Stack &$stack, bool $recursingArrays)

	executeBinaryComparisonOperation ($cellID, $operand1, $operand2, $operation, Stack &$stack, $recursingArrays=false)

	strcmpLowercaseFirst ($str1, $str2)
	Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters. More...

	strcmpAllowNull ($str1, $str2)
	PHP8.1 deprecates passing null to strcmp. More...

	executeNumericBinaryOperation ($operand1, $operand2, $operation, $matrixFunction, &$stack)

	addCellReference (array $args, $passCellReference, $functionCall, ?Cell $pCell=null)
	Add cell reference if needed while making sure that it is the last argument. More...

	getUnusedBranchStoreKey ()

	getTokensAsString ($tokens)

	evaluateDefinedName (Cell $pCell, DefinedName $namedRange, Worksheet $pCellWorksheet, Stack $stack)

Static Private Member Functions
static	loadLocales ()

static	translateFormula (array $from, array $to, $formula, $fromSeparator, $toSeparator)

static	checkMatrixOperands (&$operand1, &$operand2, $resize=1)
	Ensure that paired matrix operands are both matrices and of the same size. More...

static	resizeMatricesShrink (&$matrix1, &$matrix2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns)
	Ensure that paired matrix operands are both matrices of the same size. More...

static	resizeMatricesExtend (&$matrix1, &$matrix2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns)
	Ensure that paired matrix operands are both matrices of the same size. More...

static	dataTestReference (&$operandData)

Private Attributes
	$spreadsheet

	$calculationCache = []

	$calculationCacheEnabled = true

	$branchStoreKeyCounter = 0

	$branchPruningEnabled = true

	$debugLog

	$cyclicReferenceStack

	$cellStack = []

	$cyclicFormulaCounter = 1

	$cyclicFormulaCell = ''

	$delta = 0.1e-12

Static Private Attributes
static	$returnArrayAsType = self::RETURN_ARRAY_AS_VALUE

static	$instance

static	$operators

static	$binaryOperators

static	$referenceHelper

static	$localeLanguage = 'en_us'

static	$validLocaleLanguages

static	$localeArgumentSeparator = ','

static	$localeFunctions = []

static	$excelConstants

static	$phpSpreadsheetFunctions

static	$controlFunctions

static	$functionReplaceFromExcel = null

static	$functionReplaceToLocale = null

static	$functionReplaceFromLocale = null

static	$functionReplaceToExcel = null

static	$operatorAssociativity

static	$comparisonOperators = ['>' => true, '<' => true, '=' => true, '>=' => true, '<=' => true, '<>' => true]

static	$operatorPrecedence

Detailed Description

Definition at line 17 of file Calculation.php.

Constructor & Destructor Documentation

◆ __construct()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::__construct ( ?Spreadsheet $spreadsheet = null )

Definition at line 2758 of file Calculation.php.

    {
        $this->delta = 1 * 10 ** (0 - ini_get('precision'));
 
        $this->spreadsheet = $spreadsheet;
        $this->cyclicReferenceStack = new CyclicReferenceStack();
        $this->debugLog = new Logger($this->cyclicReferenceStack);
        self::$referenceHelper = ReferenceHelper::getInstance();
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$spreadsheet, and PhpOffice\PhpSpreadsheet\ReferenceHelper\getInstance().

Here is the call graph for this function:

Member Function Documentation

◆ __clone()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::__clone ( )

final

__clone implementation.

Cloning should not be allowed in a Singleton!

Definition at line 2824 of file Calculation.php.

    {
        throw new Exception('Cloning the calculation engine is not allowed!');
    }

◆ _calculateFormulaValue()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::_calculateFormulaValue	(		$formula,
			$cellID = `null`,
		?Cell	$pCell = `null`
	)

Parse a cell formula and calculate its value.

Parameters

string	$formula	The formula to parse and calculate
string	$cellID	The ID (e.g. A3) of the cell that we are calculating
Cell	$pCell	Cell to calculate

Returns: mixed

Definition at line 3482 of file Calculation.php.

    {
        $cellValue = null;
 
        //  Quote-Prefixed cell values cannot be formulae, but are treated as strings
        if ($pCell !== null && $pCell->getStyle()->getQuotePrefix() === true) {
            return self::wrapResult((string) $formula);
        }
 
        if (preg_match('/^=\s*cmd\s*\|/miu', $formula) !== 0) {
            return self::wrapResult($formula);
        }
 
        //    Basic validation that this is indeed a formula
        //    We simply return the cell value if not
        $formula = trim($formula);
        if ($formula[0] != '=') {
            return self::wrapResult($formula);
        }
        $formula = ltrim(substr($formula, 1));
        if (!isset($formula[0])) {
            return self::wrapResult($formula);
        }
 
        $pCellParent = ($pCell !== null) ? $pCell->getWorksheet() : null;
        $wsTitle = ($pCellParent !== null) ? $pCellParent->getTitle() : "\x00Wrk";
        $wsCellReference = $wsTitle . '!' . $cellID;
 
        if (($cellID !== null) && ($this->getValueFromCache($wsCellReference, $cellValue))) {
            return $cellValue;
        }
        $this->debugLog->writeDebugLog("Evaluating formula for cell {$wsCellReference}");
 
        if (($wsTitle[0] !== "\x00") && ($this->cyclicReferenceStack->onStack($wsCellReference))) {
            if ($this->cyclicFormulaCount <= 0) {
                $this->cyclicFormulaCell = '';
 
                return $this->raiseFormulaError('Cyclic Reference in Formula');
            } elseif ($this->cyclicFormulaCell === $wsCellReference) {
                ++$this->cyclicFormulaCounter;
                if ($this->cyclicFormulaCounter >= $this->cyclicFormulaCount) {
                    $this->cyclicFormulaCell = '';
 
                    return $cellValue;
                }
            } elseif ($this->cyclicFormulaCell == '') {
                if ($this->cyclicFormulaCounter >= $this->cyclicFormulaCount) {
                    return $cellValue;
                }
                $this->cyclicFormulaCell = $wsCellReference;
            }
        }
 
        $this->debugLog->writeDebugLog("Formula for cell {$wsCellReference} is {$formula}");
        //    Parse the formula onto the token stack and calculate the value
        $this->cyclicReferenceStack->push($wsCellReference);
 
        $cellValue = $this->processTokenStack($this->internalParseFormula($formula, $pCell), $cellID, $pCell);
        $this->cyclicReferenceStack->pop();
 
        // Save to calculation cache
        if ($cellID !== null) {
            $this->saveValueToCache($wsCellReference, $cellValue);
        }
 
        //    Return the calculated value
        return $cellValue;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$cyclicFormulaCounter, PhpOffice\PhpSpreadsheet\Calculation\Calculation\getValueFromCache(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\raiseFormulaError(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\saveValueToCache(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\wrapResult().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateCellValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateFormula().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _translateFormulaToEnglish()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::_translateFormulaToEnglish ( $formula )

Definition at line 3195 of file Calculation.php.

    {
        if (self::$functionReplaceFromLocale === null) {
            self::$functionReplaceFromLocale = [];
            foreach (self::$localeFunctions as $localeFunctionName) {
                self::$functionReplaceFromLocale[] = '/(@?[^\w\.])' . preg_quote($localeFunctionName, '/') . '([\s]*\‍()/Ui';
            }
            foreach (self::$localeBoolean as $excelBoolean) {
                self::$functionReplaceFromLocale[] = '/(@?[^\w\.])' . preg_quote($excelBoolean, '/') . '([^\w\.])/Ui';
            }
        }
 
        if (self::$functionReplaceToExcel === null) {
            self::$functionReplaceToExcel = [];
            foreach (array_keys(self::$localeFunctions) as $excelFunctionName) {
                self::$functionReplaceToExcel[] = '$1' . trim($excelFunctionName) . '$2';
            }
            foreach (array_keys(self::$localeBoolean) as $excelBoolean) {
                self::$functionReplaceToExcel[] = '$1' . trim($excelBoolean) . '$2';
            }
        }
 
        return self::translateFormula(self::$functionReplaceFromLocale, self::$functionReplaceToExcel, $formula, self::$localeArgumentSeparator, ',');
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\translateFormula().

Here is the call graph for this function:

◆ _translateFormulaToLocale()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::_translateFormulaToLocale ( $formula )

Definition at line 3166 of file Calculation.php.

    {
        if (self::$functionReplaceFromExcel === null) {
            self::$functionReplaceFromExcel = [];
            foreach (array_keys(self::$localeFunctions) as $excelFunctionName) {
                self::$functionReplaceFromExcel[] = '/(@?[^\w\.])' . preg_quote($excelFunctionName, '/') . '([\s]*\‍()/Ui';
            }
            foreach (array_keys(self::$localeBoolean) as $excelBoolean) {
                self::$functionReplaceFromExcel[] = '/(@?[^\w\.])' . preg_quote($excelBoolean, '/') . '([^\w\.])/Ui';
            }
        }
 
        if (self::$functionReplaceToLocale === null) {
            self::$functionReplaceToLocale = [];
            foreach (self::$localeFunctions as $localeFunctionName) {
                self::$functionReplaceToLocale[] = '$1' . trim($localeFunctionName) . '$2';
            }
            foreach (self::$localeBoolean as $localeBoolean) {
                self::$functionReplaceToLocale[] = '$1' . trim($localeBoolean) . '$2';
            }
        }
 
        return self::translateFormula(self::$functionReplaceFromExcel, self::$functionReplaceToLocale, $formula, ',', self::$localeArgumentSeparator);
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$localeBoolean, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\translateFormula().

Here is the call graph for this function:

◆ addCellReference()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::addCellReference	(	array	$args,
			$passCellReference,
			$functionCall,
		?Cell	$pCell = `null`
	)

private

Add cell reference if needed while making sure that it is the last argument.

Parameters

bool	$passCellReference
array \| string	$functionCall

Returns: array

Definition at line 5397 of file Calculation.php.

    {
        if ($passCellReference) {
            if (is_array($functionCall)) {
                $className = $functionCall[0];
                $methodName = $functionCall[1];
 
                $reflectionMethod = new ReflectionMethod($className, $methodName);
                $argumentCount = count($reflectionMethod->getParameters());
                while (count($args) < $argumentCount - 1) {
                    $args[] = null;
                }
            }
 
            $args[] = $pCell;
        }
 
        return $args;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the caller graph for this function:

◆ calculate()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::calculate ( ?Cell $pCell = null )

Calculate cell value (using formula from a cell ID) Retained for backward compatibility.

Parameters

Cell $pCell Cell to calculate

Returns: mixed

Definition at line 3291 of file Calculation.php.

    {
        try {
            return $this->calculateCellValue($pCell);
        } catch (\Exception $e) {
            throw new Exception($e->getMessage());
        }
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateCellValue().

Here is the call graph for this function:

◆ calculateCellValue()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::calculateCellValue	(	?Cell	$pCell = `null`,
			$resetLog = `true`
	)

Calculate the value of a cell formula.

Parameters

Cell	$pCell	Cell to calculate
bool	$resetLog	Flag indicating whether the debug log should be reset or not

Returns: mixed

Definition at line 3308 of file Calculation.php.

    {
        if ($pCell === null) {
            return null;
        }
 
        $returnArrayAsType = self::$returnArrayAsType;
        if ($resetLog) {
            //    Initialise the logging settings if requested
            $this->formulaError = null;
            $this->debugLog->clearLog();
            $this->cyclicReferenceStack->clear();
            $this->cyclicFormulaCounter = 1;
 
            self::$returnArrayAsType = self::RETURN_ARRAY_AS_ARRAY;
        }
 
        //    Execute the calculation for the cell formula
        $this->cellStack[] = [
            'sheet' => $pCell->getWorksheet()->getTitle(),
            'cell' => $pCell->getCoordinate(),
        ];
 
        try {
            $result = self::unwrapResult($this->_calculateFormulaValue($pCell->getValue(), $pCell->getCoordinate(), $pCell));
            $cellAddress = array_pop($this->cellStack);
            $this->spreadsheet->getSheetByName($cellAddress['sheet'])->getCell($cellAddress['cell']);
        } catch (\Exception $e) {
            $cellAddress = array_pop($this->cellStack);
            $this->spreadsheet->getSheetByName($cellAddress['sheet'])->getCell($cellAddress['cell']);
 
            throw new Exception($e->getMessage());
        }
 
        if ((is_array($result)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {
            self::$returnArrayAsType = $returnArrayAsType;
            $testResult = Functions::flattenArray($result);
            if (self::$returnArrayAsType == self::RETURN_ARRAY_AS_ERROR) {
                return Functions::VALUE();
            }
            //    If there's only a single cell in the array, then we allow it
            if (count($testResult) != 1) {
                //    If keys are numeric, then it's a matrix result rather than a cell range result, so we permit it
                $r = array_keys($result);
                $r = array_shift($r);
                if (!is_numeric($r)) {
                    return Functions::VALUE();
                }
                if (is_array($result[$r])) {
                    $c = array_keys($result[$r]);
                    $c = array_shift($c);
                    if (!is_numeric($c)) {
                        return Functions::VALUE();
                    }
                }
            }
            $result = array_shift($testResult);
        }
        self::$returnArrayAsType = $returnArrayAsType;
 
        if ($result === null && $pCell->getWorksheet()->getSheetView()->getShowZeros()) {
            return 0;
        } elseif ((is_float($result)) && ((is_nan($result)) || (is_infinite($result)))) {
            return Functions::NAN();
        }
 
        return $result;
    }

References $c, $r, $result, PhpOffice\PhpSpreadsheet\Calculation\Calculation\$returnArrayAsType, PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenArray(), PhpOffice\PhpSpreadsheet\Calculation\Functions\NAN(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\RETURN_ARRAY_AS_ARRAY, PhpOffice\PhpSpreadsheet\Calculation\Calculation\unwrapResult(), and PhpOffice\PhpSpreadsheet\Calculation\Functions\VALUE().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculateFormula()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::calculateFormula	(		$formula,
			$cellID = `null`,
		?Cell	$pCell = `null`
	)

Calculate the value of a formula.

Parameters

string	$formula	Formula to parse
string	$cellID	Address of the cell to calculate
Cell	$pCell	Cell to calculate

Returns: mixed

Definition at line 3410 of file Calculation.php.

    {
        //    Initialise the logging settings
        $this->formulaError = null;
        $this->debugLog->clearLog();
        $this->cyclicReferenceStack->clear();
 
        $resetCache = $this->getCalculationCacheEnabled();
        if ($this->spreadsheet !== null && $cellID === null && $pCell === null) {
            $cellID = 'A1';
            $pCell = $this->spreadsheet->getActiveSheet()->getCell($cellID);
        } else {
            //    Disable calculation cacheing because it only applies to cell calculations, not straight formulae
            //    But don't actually flush any cache
            $this->calculationCacheEnabled = false;
        }
 
        //    Execute the calculation
        try {
            $result = self::unwrapResult($this->_calculateFormulaValue($formula, $cellID, $pCell));
        } catch (\Exception $e) {
            throw new Exception($e->getMessage());
        }
 
        if ($this->spreadsheet === null) {
            //    Reset calculation cacheing to its previous state
            $this->calculationCacheEnabled = $resetCache;
        }
 
        return $result;
    }

References $result, PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\getCalculationCacheEnabled(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\unwrapResult().

Here is the call graph for this function:

◆ checkMatrixOperands()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::checkMatrixOperands	(	&	$operand1,
		&	$operand2,
			$resize = `1`
	)

staticprivate

Ensure that paired matrix operands are both matrices and of the same size.

Parameters

mixed	$operand1	First matrix operand
mixed	$operand2	Second matrix operand
int	$resize	Flag indicating whether the matrices should be resized to match and (if so), whether the smaller dimension should grow or the larger should shrink. 0 = no resize 1 = shrink to fit 2 = extend to fit

Returns: array

Definition at line 3565 of file Calculation.php.

    {
        //    Examine each of the two operands, and turn them into an array if they aren't one already
        //    Note that this function should only be called if one or both of the operand is already an array
        if (!is_array($operand1)) {
            [$matrixRows, $matrixColumns] = self::getMatrixDimensions($operand2);
            $operand1 = array_fill(0, $matrixRows, array_fill(0, $matrixColumns, $operand1));
            $resize = 0;
        } elseif (!is_array($operand2)) {
            [$matrixRows, $matrixColumns] = self::getMatrixDimensions($operand1);
            $operand2 = array_fill(0, $matrixRows, array_fill(0, $matrixColumns, $operand2));
            $resize = 0;
        }
 
        [$matrix1Rows, $matrix1Columns] = self::getMatrixDimensions($operand1);
        [$matrix2Rows, $matrix2Columns] = self::getMatrixDimensions($operand2);
        if (($matrix1Rows == $matrix2Columns) && ($matrix2Rows == $matrix1Columns)) {
            $resize = 1;
        }
 
        if ($resize == 2) {
            //    Given two matrices of (potentially) unequal size, convert the smaller in each dimension to match the larger
            self::resizeMatricesExtend($operand1, $operand2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns);
        } elseif ($resize == 1) {
            //    Given two matrices of (potentially) unequal size, convert the larger in each dimension to match the smaller
            self::resizeMatricesShrink($operand1, $operand2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns);
        }
 
        return [$matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns];
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\getMatrixDimensions(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\resizeMatricesExtend(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\resizeMatricesShrink().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeArrayComparison(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeNumericBinaryOperation(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clearBranchStore()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::clearBranchStore ( )

Definition at line 2972 of file Calculation.php.

                                      : void
    {
        $this->branchStoreKeyCounter = 0;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\flushInstance().

Here is the caller graph for this function:

◆ clearCalculationCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::clearCalculationCache ( )

Clear calculation cache.

Definition at line 2921 of file Calculation.php.

                                           : void
    {
        $this->calculationCache = [];
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\flushInstance(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\setCalculationCacheEnabled().

Here is the caller graph for this function:

◆ clearCalculationCacheForWorksheet()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::clearCalculationCacheForWorksheet ( $worksheetName )

Clear calculation cache for a specified worksheet.

Parameters

string $worksheetName

Definition at line 2931 of file Calculation.php.

                                                                     : void
    {
        if (isset($this->calculationCache[$worksheetName])) {
            unset($this->calculationCache[$worksheetName]);
        }
    }

◆ convertMatrixReferences()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::convertMatrixReferences ( $formula )

private

Parameters

string $formula

Returns: false|string False indicates an error

Definition at line 3794 of file Calculation.php.

    {
        static $matrixReplaceFrom = [self::FORMULA_OPEN_FUNCTION_BRACE, ';', self::FORMULA_CLOSE_FUNCTION_BRACE];
        static $matrixReplaceTo = ['MKMATRIX(MKMATRIX(', '),MKMATRIX(', '))'];
 
        //    Convert any Excel matrix references to the MKMATRIX() function
        if (strpos($formula, self::FORMULA_OPEN_FUNCTION_BRACE) !== false) {
            //    If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
            if (strpos($formula, self::FORMULA_STRING_QUOTE) !== false) {
                //    So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
                //        the formula
                $temp = explode(self::FORMULA_STRING_QUOTE, $formula);
                //    Open and Closed counts used for trapping mismatched braces in the formula
                $openCount = $closeCount = 0;
                $i = false;
                foreach ($temp as &$value) {
                    //    Only count/replace in alternating array entries
                    if ($i = !$i) {
                        $openCount += substr_count($value, self::FORMULA_OPEN_FUNCTION_BRACE);
                        $closeCount += substr_count($value, self::FORMULA_CLOSE_FUNCTION_BRACE);
                        $value = str_replace($matrixReplaceFrom, $matrixReplaceTo, $value);
                    }
                }
                unset($value);
                //    Then rebuild the formula string
                $formula = implode(self::FORMULA_STRING_QUOTE, $temp);
            } else {
                //    If there's no quoted strings, then we do a simple count/replace
                $openCount = substr_count($formula, self::FORMULA_OPEN_FUNCTION_BRACE);
                $closeCount = substr_count($formula, self::FORMULA_CLOSE_FUNCTION_BRACE);
                $formula = str_replace($matrixReplaceFrom, $matrixReplaceTo, $formula);
            }
            //    Trap for mismatched braces and trigger an appropriate error
            if ($openCount < $closeCount) {
                if ($openCount > 0) {
                    return $this->raiseFormulaError("Formula Error: Mismatched matrix braces '}'");
                }
 
                return $this->raiseFormulaError("Formula Error: Unexpected '}' encountered");
            } elseif ($openCount > $closeCount) {
                if ($closeCount > 0) {
                    return $this->raiseFormulaError("Formula Error: Mismatched matrix braces '{'");
                }
 
                return $this->raiseFormulaError("Formula Error: Unexpected '{' encountered");
            }
        }
 
        return $formula;
    }

References $i, PhpOffice\PhpSpreadsheet\Calculation\Calculation\FORMULA_CLOSE_FUNCTION_BRACE, PhpOffice\PhpSpreadsheet\Calculation\Calculation\FORMULA_OPEN_FUNCTION_BRACE, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\raiseFormulaError().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dataTestReference()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::dataTestReference ( & $operandData )

staticprivate

Definition at line 4361 of file Calculation.php.

    {
        $operand = $operandData['value'];
        if (($operandData['reference'] === null) && (is_array($operand))) {
            $rKeys = array_keys($operand);
            $rowKey = array_shift($rKeys);
            $cKeys = array_keys(array_keys($operand[$rowKey]));
            $colKey = array_shift($cKeys);
            if (ctype_upper($colKey)) {
                $operandData['reference'] = $colKey . $rowKey;
            }
        }
 
        return $operand;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the caller graph for this function:

◆ disableBranchPruning()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::disableBranchPruning ( )

Definition at line 2967 of file Calculation.php.

                                          : void
    {
        $this->setBranchPruningEnabled(false);
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setBranchPruningEnabled().

Here is the call graph for this function:

◆ disableCalculationCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::disableCalculationCache ( )

Disable calculation cache.

Definition at line 2913 of file Calculation.php.

                                             : void
    {
        $this->setCalculationCacheEnabled(false);
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setCalculationCacheEnabled().

Here is the call graph for this function:

◆ enableBranchPruning()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::enableBranchPruning ( )

Definition at line 2962 of file Calculation.php.

                                         : void
    {
        $this->setBranchPruningEnabled(true);
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setBranchPruningEnabled().

Here is the call graph for this function:

◆ enableCalculationCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::enableCalculationCache ( )

Enable calculation cache.

Definition at line 2905 of file Calculation.php.

                                            : void
    {
        $this->setCalculationCacheEnabled(true);
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\setCalculationCacheEnabled().

Here is the call graph for this function:

◆ evaluateDefinedName()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::evaluateDefinedName	(	Cell	$pCell,
		DefinedName	$namedRange,
		Worksheet	$pCellWorksheet,
		Stack	$stack
	)

private

Returns: mixed|string

Definition at line 5442 of file Calculation.php.

    {
        $definedNameScope = $namedRange->getScope();
        if ($definedNameScope !== null && $definedNameScope !== $pCellWorksheet) {
            // The defined name isn't in our current scope, so #REF
            $result = Functions::REF();
            $stack->push('Error', $result, $namedRange->getName());
 
            return $result;
        }
 
        $definedNameValue = $namedRange->getValue();
        $definedNameType = $namedRange->isFormula() ? 'Formula' : 'Range';
        $definedNameWorksheet = $namedRange->getWorksheet();
 
        if ($definedNameValue[0] !== '=') {
            $definedNameValue = '=' . $definedNameValue;
        }
 
        $this->debugLog->writeDebugLog("Defined Name is a {$definedNameType} with a value of {$definedNameValue}");
 
        $recursiveCalculationCell = ($definedNameWorksheet !== null && $definedNameWorksheet !== $pCellWorksheet)
            ? $definedNameWorksheet->getCell('A1')
            : $pCell;
        $recursiveCalculationCellAddress = $recursiveCalculationCell->getCoordinate();
 
        // Adjust relative references in ranges and formulae so that we execute the calculation for the correct rows and columns
        $definedNameValue = self::$referenceHelper->updateFormulaReferencesAnyWorksheet(
            $definedNameValue,
            Coordinate::columnIndexFromString($pCell->getColumn()) - 1,
            $pCell->getRow() - 1
        );
 
        $this->debugLog->writeDebugLog("Value adjusted for relative references is {$definedNameValue}");
 
        $recursiveCalculator = new self($this->spreadsheet);
        $recursiveCalculator->getDebugLog()->setWriteDebugLog($this->getDebugLog()->getWriteDebugLog());
        $recursiveCalculator->getDebugLog()->setEchoDebugLog($this->getDebugLog()->getEchoDebugLog());
        $result = $recursiveCalculator->_calculateFormulaValue($definedNameValue, $recursiveCalculationCellAddress, $recursiveCalculationCell);
 
        if ($this->getDebugLog()->getWriteDebugLog()) {
            $this->debugLog->mergeDebugLog(array_slice($recursiveCalculator->getDebugLog()->getLog(), 3));
            $this->debugLog->writeDebugLog("Evaluation Result for Named {$definedNameType} {$namedRange->getName()} is {$this->showTypeDetails($result)}");
        }
 
        $stack->push('Defined Name', $result, $namedRange->getName());
 
        return $result;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeArrayComparison()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::executeArrayComparison	(		$cellID,
			$operand1,
			$operand2,
			$operation,
		Stack &	$stack,
		bool	$recursingArrays
	)

private

Parameters

null \| string	$cellID
mixed	$operand1
mixed	$operand2
string	$operation

Returns: array

Definition at line 4948 of file Calculation.php.

    {
        $result = [];
        if (!is_array($operand2)) {
            // Operand 1 is an array, Operand 2 is a scalar
            foreach ($operand1 as $x => $operandData) {
                $this->debugLog->writeDebugLog('Evaluating Comparison ', $this->showValue($operandData), ' ', $operation, ' ', $this->showValue($operand2));
                $this->executeBinaryComparisonOperation($cellID, $operandData, $operand2, $operation, $stack);
                $r = $stack->pop();
                $result[$x] = $r['value'];
            }
        } elseif (!is_array($operand1)) {
            // Operand 1 is a scalar, Operand 2 is an array
            foreach ($operand2 as $x => $operandData) {
                $this->debugLog->writeDebugLog('Evaluating Comparison ', $this->showValue($operand1), ' ', $operation, ' ', $this->showValue($operandData));
                $this->executeBinaryComparisonOperation($cellID, $operand1, $operandData, $operation, $stack);
                $r = $stack->pop();
                $result[$x] = $r['value'];
            }
        } else {
            // Operand 1 and Operand 2 are both arrays
            if (!$recursingArrays) {
                self::checkMatrixOperands($operand1, $operand2, 2);
            }
            foreach ($operand1 as $x => $operandData) {
                $this->debugLog->writeDebugLog('Evaluating Comparison ', $this->showValue($operandData), ' ', $operation, ' ', $this->showValue($operand2[$x]));
                $this->executeBinaryComparisonOperation($cellID, $operandData, $operand2[$x], $operation, $stack, true);
                $r = $stack->pop();
                $result[$x] = $r['value'];
            }
        }
        //    Log the result details
        $this->debugLog->writeDebugLog('Comparison Evaluation Result is ', $this->showTypeDetails($result));
        //    And push the result onto the stack
        $stack->push('Array', $result);
 
        return $result;
    }

References $r, $result, $x, PhpOffice\PhpSpreadsheet\Calculation\Calculation\checkMatrixOperands(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation(), PhpOffice\PhpSpreadsheet\Calculation\Token\Stack\pop(), PhpOffice\PhpSpreadsheet\Calculation\Token\Stack\push(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showValue().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeBinaryComparisonOperation()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::executeBinaryComparisonOperation	(		$cellID,
			$operand1,
			$operand2,
			$operation,
		Stack &	$stack,
			$recursingArrays = `false`
	)

private

Parameters

null \| string	$cellID
mixed	$operand1
mixed	$operand2
string	$operation
bool	$recursingArrays

Returns: mixed

Definition at line 4996 of file Calculation.php.

    {
        //    If we're dealing with matrix operations, we want a matrix result
        if ((is_array($operand1)) || (is_array($operand2))) {
            return $this->executeArrayComparison($cellID, $operand1, $operand2, $operation, $stack, $recursingArrays);
        }
 
        //    Simple validate the two operands if they are string values
        if (is_string($operand1) && $operand1 > '' && $operand1[0] == self::FORMULA_STRING_QUOTE) {
            $operand1 = self::unwrapResult($operand1);
        }
        if (is_string($operand2) && $operand2 > '' && $operand2[0] == self::FORMULA_STRING_QUOTE) {
            $operand2 = self::unwrapResult($operand2);
        }
 
        // Use case insensitive comparaison if not OpenOffice mode
        if (Functions::getCompatibilityMode() != Functions::COMPATIBILITY_OPENOFFICE) {
            if (is_string($operand1)) {
                $operand1 = Shared\StringHelper::strToUpper($operand1);
            }
            if (is_string($operand2)) {
                $operand2 = Shared\StringHelper::strToUpper($operand2);
            }
        }
 
        $useLowercaseFirstComparison = is_string($operand1) && is_string($operand2) && Functions::getCompatibilityMode() == Functions::COMPATIBILITY_OPENOFFICE;
 
        //    execute the necessary operation
        switch ($operation) {
            //    Greater than
            case '>':
                if ($useLowercaseFirstComparison) {
                    $result = $this->strcmpLowercaseFirst($operand1, $operand2) > 0;
                } else {
                    $result = ($operand1 > $operand2);
                }
 
                break;
            //    Less than
            case '<':
                if ($useLowercaseFirstComparison) {
                    $result = $this->strcmpLowercaseFirst($operand1, $operand2) < 0;
                } else {
                    $result = ($operand1 < $operand2);
                }
 
                break;
            //    Equality
            case '=':
                if (is_numeric($operand1) && is_numeric($operand2)) {
                    $result = (abs($operand1 - $operand2) < $this->delta);
                } else {
                    $result = $this->strcmpAllowNull($operand1, $operand2) == 0;
                }
 
                break;
            //    Greater than or equal
            case '>=':
                if (is_numeric($operand1) && is_numeric($operand2)) {
                    $result = ((abs($operand1 - $operand2) < $this->delta) || ($operand1 > $operand2));
                } elseif ($useLowercaseFirstComparison) {
                    $result = $this->strcmpLowercaseFirst($operand1, $operand2) >= 0;
                } else {
                    $result = $this->strcmpAllowNull($operand1, $operand2) >= 0;
                }
 
                break;
            //    Less than or equal
            case '<=':
                if (is_numeric($operand1) && is_numeric($operand2)) {
                    $result = ((abs($operand1 - $operand2) < $this->delta) || ($operand1 < $operand2));
                } elseif ($useLowercaseFirstComparison) {
                    $result = $this->strcmpLowercaseFirst($operand1, $operand2) <= 0;
                } else {
                    $result = $this->strcmpAllowNull($operand1, $operand2) <= 0;
                }
 
                break;
            //    Inequality
            case '<>':
                if (is_numeric($operand1) && is_numeric($operand2)) {
                    $result = (abs($operand1 - $operand2) > 1E-14);
                } else {
                    $result = $this->strcmpAllowNull($operand1, $operand2) != 0;
                }
 
                break;
 
            default:
                throw new Exception('Unsupported binary comparison operation');
        }
 
        //    Log the result details
        $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
        //    And push the result onto the stack
        $stack->push('Value', $result);
 
        return $result;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeArrayComparison(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeNumericBinaryOperation()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::executeNumericBinaryOperation	(		$operand1,
			$operand2,
			$operation,
			$matrixFunction,
		&	$stack
	)

private

Parameters

mixed	$operand1
mixed	$operand2
mixed	$operation
string	$matrixFunction
mixed	$stack

Returns: bool|mixed

Definition at line 5134 of file Calculation.php.

    {
        //    Validate the two operands
        if (!$this->validateBinaryOperand($operand1, $stack)) {
            return false;
        }
        if (!$this->validateBinaryOperand($operand2, $stack)) {
            return false;
        }
 
        //    If either of the operands is a matrix, we need to treat them both as matrices
        //        (converting the other operand to a matrix if need be); then perform the required
        //        matrix operation
        if ((is_array($operand1)) || (is_array($operand2))) {
            //    Ensure that both operands are arrays/matrices of the same size
            self::checkMatrixOperands($operand1, $operand2, 2);
 
            try {
                //    Convert operand 1 from a PHP array to a matrix
                $matrix = new Shared\JAMA\Matrix($operand1);
                //    Perform the required operation against the operand 1 matrix, passing in operand 2
                $matrixResult = $matrix->$matrixFunction($operand2);
                $result = $matrixResult->getArray();
            } catch (\Exception $ex) {
                $this->debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                $result = '#VALUE!';
            }
        } else {
            if (
                (Functions::getCompatibilityMode() != Functions::COMPATIBILITY_OPENOFFICE) &&
                ((is_string($operand1) && !is_numeric($operand1) && strlen($operand1) > 0) ||
                    (is_string($operand2) && !is_numeric($operand2) && strlen($operand2) > 0))
            ) {
                $result = Functions::VALUE();
            } else {
                //    If we're dealing with non-matrix operations, execute the necessary operation
                switch ($operation) {
                    //    Addition
                    case '+':
                        $result = $operand1 + $operand2;
 
                        break;
                    //    Subtraction
                    case '-':
                        $result = $operand1 - $operand2;
 
                        break;
                    //    Multiplication
                    case '*':
                        $result = $operand1 * $operand2;
 
                        break;
                    //    Division
                    case '/':
                        if ($operand2 == 0) {
                            //    Trap for Divide by Zero error
                            $stack->push('Error', '#DIV/0!');
                            $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails('#DIV/0!'));
 
                            return false;
                        }
                        $result = $operand1 / $operand2;
 
                        break;
                    //    Power
                    case '^':
                        $result = $operand1 ** $operand2;
 
                        break;
 
                    default:
                        throw new Exception('Unsupported numeric binary operation');
                }
            }
        }
 
        //    Log the result details
        $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
        //    And push the result onto the stack
        $stack->push('Value', $result);
 
        return $result;
    }

References $matrix, $result, PhpOffice\PhpSpreadsheet\Calculation\Calculation\checkMatrixOperands(), PhpOffice\PhpSpreadsheet\Calculation\Functions\COMPATIBILITY_OPENOFFICE, PhpOffice\PhpSpreadsheet\Calculation\Functions\getCompatibilityMode(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\validateBinaryOperand(), and PhpOffice\PhpSpreadsheet\Calculation\Functions\VALUE().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extractCellRange()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::extractCellRange	(	&	$pRange = `'A1'`,
		?Worksheet	$pSheet = `null`,
			$resetLog = `true`
	)

Extract range values.

Parameters

string	$pRange	String based range representation
Worksheet	$pSheet	Worksheet
bool	$resetLog	Flag indicating whether calculation log should be reset or not

Returns: mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.

Definition at line 5240 of file Calculation.php.

    {
        // Return value
        $returnValue = [];
 
        if ($pSheet !== null) {
            $pSheetName = $pSheet->getTitle();
 
            if (strpos($pRange, '!') !== false) {
                [$pSheetName, $pRange] = Worksheet::extractSheetTitle($pRange, true);
                $pSheet = $this->spreadsheet->getSheetByName($pSheetName);
            }
 
            // Extract range
            $aReferences = Coordinate::extractAllCellReferencesInRange($pRange);
            $pRange = $pSheetName . '!' . $pRange;
            if (!isset($aReferences[1])) {
                $currentCol = '';
                $currentRow = 0;
                //    Single cell in range
                sscanf($aReferences[0], '%[A-Z]%d', $currentCol, $currentRow);
                if ($pSheet->cellExists($aReferences[0])) {
                    $returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
                } else {
                    $returnValue[$currentRow][$currentCol] = null;
                }
            } else {
                // Extract cell data for all cells in the range
                foreach ($aReferences as $reference) {
                    $currentCol = '';
                    $currentRow = 0;
                    // Extract range
                    sscanf($reference, '%[A-Z]%d', $currentCol, $currentRow);
                    if ($pSheet->cellExists($reference)) {
                        $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
                    } else {
                        $returnValue[$currentRow][$currentCol] = null;
                    }
                }
            }
        }
 
        return $returnValue;
    }

References PhpOffice\PhpSpreadsheet\Cell\Coordinate\extractAllCellReferencesInRange().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ extractNamedRange()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::extractNamedRange	(	&	$pRange = `'A1'`,
		?Worksheet	$pSheet = `null`,
			$resetLog = `true`
	)

Extract range values.

Parameters

string	$pRange	String based range representation
Worksheet	$pSheet	Worksheet
bool	$resetLog	Flag indicating whether calculation log should be reset or not

Returns: mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.

Definition at line 5294 of file Calculation.php.

    {
        // Return value
        $returnValue = [];
 
        if ($pSheet !== null) {
            $pSheetName = $pSheet->getTitle();
            if (strpos($pRange, '!') !== false) {
                [$pSheetName, $pRange] = Worksheet::extractSheetTitle($pRange, true);
                $pSheet = $this->spreadsheet->getSheetByName($pSheetName);
            }
 
            // Named range?
            $namedRange = DefinedName::resolveName($pRange, $pSheet);
            if ($namedRange === null) {
                return Functions::REF();
            }
 
            $pSheet = $namedRange->getWorksheet();
            $pRange = $namedRange->getValue();
            $splitRange = Coordinate::splitRange($pRange);
            //    Convert row and column references
            if (ctype_alpha($splitRange[0][0])) {
                $pRange = $splitRange[0][0] . '1:' . $splitRange[0][1] . $namedRange->getWorksheet()->getHighestRow();
            } elseif (ctype_digit($splitRange[0][0])) {
                $pRange = 'A' . $splitRange[0][0] . ':' . $namedRange->getWorksheet()->getHighestColumn() . $splitRange[0][1];
            }
 
            // Extract range
            $aReferences = Coordinate::extractAllCellReferencesInRange($pRange);
            if (!isset($aReferences[1])) {
                //    Single cell (or single column or row) in range
                [$currentCol, $currentRow] = Coordinate::coordinateFromString($aReferences[0]);
                if ($pSheet->cellExists($aReferences[0])) {
                    $returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
                } else {
                    $returnValue[$currentRow][$currentCol] = null;
                }
            } else {
                // Extract cell data for all cells in the range
                foreach ($aReferences as $reference) {
                    // Extract range
                    [$currentCol, $currentRow] = Coordinate::coordinateFromString($reference);
                    if ($pSheet->cellExists($reference)) {
                        $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
                    } else {
                        $returnValue[$currentRow][$currentCol] = null;
                    }
                }
            }
        }
 
        return $returnValue;
    }

References PhpOffice\PhpSpreadsheet\Cell\Coordinate\coordinateFromString(), PhpOffice\PhpSpreadsheet\Cell\Coordinate\extractAllCellReferencesInRange(), PhpOffice\PhpSpreadsheet\Calculation\Functions\REF(), PhpOffice\PhpSpreadsheet\DefinedName\resolveName(), and PhpOffice\PhpSpreadsheet\Cell\Coordinate\splitRange().

Here is the call graph for this function:

◆ flushInstance()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::flushInstance ( )

Flush the calculation cache for any existing instance of this class but only if a Calculation instance exists.

Definition at line 2805 of file Calculation.php.

                                   : void
    {
        $this->clearCalculationCache();
        $this->clearBranchStore();
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\clearBranchStore(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\clearCalculationCache().

Here is the call graph for this function:

◆ getArrayReturnType()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getArrayReturnType ( )

static

Return the Array Return Type (Array or Value of first element in the array).

Returns: string $returnType Array return type

Definition at line 2876 of file Calculation.php.

    {
        return self::$returnArrayAsType;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$returnArrayAsType.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Html\generateHtmlAll(), and PhpOffice\PhpSpreadsheet\Writer\Csv\save().

Here is the caller graph for this function:

◆ getCalculationCacheEnabled()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getCalculationCacheEnabled ( )

Is calculation caching enabled?

Returns: bool

Definition at line 2886 of file Calculation.php.

    {
        return $this->calculationCacheEnabled;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$calculationCacheEnabled.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateFormula().

Here is the caller graph for this function:

◆ getDebugLog()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getDebugLog ( )

Get the Logger for this calculation engine instance.

Returns: Logger

Definition at line 2816 of file Calculation.php.

    {
        return $this->debugLog;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$debugLog.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\evaluateDefinedName().

Here is the caller graph for this function:

◆ getFALSE()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getFALSE ( )

static

Return the locale-specific translation of FALSE.

Returns: string locale-specific translation of FALSE

Definition at line 2844 of file Calculation.php.

                                     : string
    {
        return self::$localeBoolean['FALSE'];
    }

Here is the caller graph for this function:

◆ getFunctions()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getFunctions ( )

Get a list of all implemented functions as an array of function objects.

Definition at line 5367 of file Calculation.php.

                                  : array
    {
        return self::$phpSpreadsheetFunctions;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$phpSpreadsheetFunctions.

◆ getImplementedFunctionNames()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getImplementedFunctionNames ( )

Get a list of implemented Excel function names.

Returns: array

Definition at line 5377 of file Calculation.php.

    {
        $returnValue = [];
        foreach (self::$phpSpreadsheetFunctions as $functionName => $function) {
            if ($this->isImplemented($functionName)) {
                $returnValue[] = $functionName;
            }
        }
 
        return $returnValue;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\isImplemented().

Here is the call graph for this function:

◆ getInstance()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getInstance ( ?Spreadsheet $spreadsheet = null )

static

Get an instance of this class.

Parameters

?Spreadsheet $spreadsheet Injected spreadsheet for working with a PhpSpreadsheet Spreadsheet object, or NULL to create a standalone calculation engine

Definition at line 2785 of file Calculation.php.

                                                                        : self
    {
        if ($spreadsheet !== null) {
            $instance = $spreadsheet->getCalculationEngine();
            if (isset($instance)) {
                return $instance;
            }
        }
 
        if (!isset(self::$instance) || (self::$instance === null)) {
            self::$instance = new self();
        }
 
        return self::$instance;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$instance, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\$spreadsheet.

Here is the caller graph for this function:

◆ getLocale()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getLocale ( )

Get the currently defined locale code.

Returns: string

Definition at line 2982 of file Calculation.php.

    {
        return self::$localeLanguage;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$localeLanguage.

◆ getLocaleFile()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getLocaleFile	(	string	$localeDir,
		string	$locale,
		string	$language,
		string	$file
	)

private

Definition at line 2987 of file Calculation.php.

                                                                                                     : string
    {
        $localeFileName = $localeDir . str_replace('_', DIRECTORY_SEPARATOR, $locale) .
            DIRECTORY_SEPARATOR . $file;
        if (!file_exists($localeFileName)) {
            //    If there isn't a locale specific file, look for a language specific file
            $localeFileName = $localeDir . $language . DIRECTORY_SEPARATOR . $file;
            if (!file_exists($localeFileName)) {
                throw new Exception('Locale file not found');
            }
        }
 
        return $localeFileName;
    }

References $language.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\setLocale().

Here is the caller graph for this function:

◆ getMatrixDimensions()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getMatrixDimensions ( array & $matrix )

static

Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0.

Parameters

array $matrix matrix operand

Returns: int[] An array comprising the number of rows, and number of columns

Definition at line 3603 of file Calculation.php.

    {
        $matrixRows = count($matrix);
        $matrixColumns = 0;
        foreach ($matrix as $rowKey => $rowValue) {
            if (!is_array($rowValue)) {
                $matrix[$rowKey] = [$rowValue];
                $matrixColumns = max(1, $matrixColumns);
            } else {
                $matrix[$rowKey] = array_values($rowValue);
                $matrixColumns = max(count($rowValue), $matrixColumns);
            }
        }
        $matrix = array_values($matrix);
 
        return [$matrixRows, $matrixColumns];
    }

References $matrix.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\checkMatrixOperands(), PhpOffice\PhpSpreadsheet\Calculation\LookupRef\RowColumnInformation\COLUMNS(), and PhpOffice\PhpSpreadsheet\Calculation\LookupRef\RowColumnInformation\ROWS().

Here is the caller graph for this function:

◆ getTokensAsString()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getTokensAsString ( $tokens )

private

Definition at line 5425 of file Calculation.php.

    {
        $tokensStr = array_map(function ($token) {
            $value = $token['value'] ?? 'no value';
            while (is_array($value)) {
                $value = array_pop($value);
            }
 
            return $value;
        }, $tokens);
 
        return '[ ' . implode(' | ', $tokensStr) . ' ]';
    }

References PHPMailer\PHPMailer\$token.

◆ getTRUE()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::getTRUE ( )

static

Return the locale-specific translation of TRUE.

Returns: string locale-specific translation of TRUE

Definition at line 2834 of file Calculation.php.

                                    : string
    {
        return self::$localeBoolean['TRUE'];
    }

Here is the caller graph for this function:

◆ getUnusedBranchStoreKey()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getUnusedBranchStoreKey ( )

private

Definition at line 5417 of file Calculation.php.

    {
        $storeKeyValue = 'storeKey-' . $this->branchStoreKeyCounter;
        ++$this->branchStoreKeyCounter;
 
        return $storeKeyValue;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\$branchStoreKeyCounter.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula().

Here is the caller graph for this function:

◆ getValueFromCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::getValueFromCache	(	string	$cellReference,
		&	$cellValue
	)

Parameters

mixed $cellValue

Definition at line 3445 of file Calculation.php.

                                                                         : bool
    {
        $this->debugLog->writeDebugLog("Testing cache value for cell {$cellReference}");
        // Is calculation cacheing enabled?
        // If so, is the required value present in calculation cache?
        if (($this->calculationCacheEnabled) && (isset($this->calculationCache[$cellReference]))) {
            $this->debugLog->writeDebugLog("Retrieving value for cell {$cellReference} from cache");
            // Return the cached result
 
            $cellValue = $this->calculationCache[$cellReference];
 
            return true;
        }
 
        return false;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

Here is the caller graph for this function:

◆ internalParseFormula()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::internalParseFormula	(		$formula,
		?Cell	$pCell = `null`
	)

private

Parameters

string $formula

Returns: array<int, mixed>|false

Definition at line 3883 of file Calculation.php.

    {
        if (($formula = $this->convertMatrixReferences(trim($formula))) === false) {
            return false;
        }
 
        //    If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent worksheet),
        //        so we store the parent worksheet so that we can re-attach it when necessary
        $pCellParent = ($pCell !== null) ? $pCell->getWorksheet() : null;
 
        $regexpMatchString = '/^(' . self::CALCULATION_REGEXP_FUNCTION .
            '|' . self::CALCULATION_REGEXP_CELLREF .
            '|' . self::CALCULATION_REGEXP_COLUMN_RANGE .
            '|' . self::CALCULATION_REGEXP_ROW_RANGE .
            '|' . self::CALCULATION_REGEXP_NUMBER .
            '|' . self::CALCULATION_REGEXP_STRING .
            '|' . self::CALCULATION_REGEXP_OPENBRACE .
            '|' . self::CALCULATION_REGEXP_DEFINEDNAME .
            '|' . self::CALCULATION_REGEXP_ERROR .
            ')/sui';
 
        //    Start with initialisation
        $index = 0;
        $stack = new Stack();
        $output = [];
        $expectingOperator = false; //    We use this test in syntax-checking the expression to determine when a
        //        - is a negation or + is a positive operator rather than an operation
        $expectingOperand = false; //    We use this test in syntax-checking the expression to determine whether an operand
        //        should be null in a function call
 
        // IF branch pruning
        // currently pending storeKey (last item of the storeKeysStack
        $pendingStoreKey = null;
        // stores a list of storeKeys (string[])
        $pendingStoreKeysStack = [];
        $expectingConditionMap = []; // ['storeKey' => true, ...]
        $expectingThenMap = []; // ['storeKey' => true, ...]
        $expectingElseMap = []; // ['storeKey' => true, ...]
        $parenthesisDepthMap = []; // ['storeKey' => 4, ...]
 
        //    The guts of the lexical parser
        //    Loop through the formula extracting each operator and operand in turn
        while (true) {
            // Branch pruning: we adapt the output item to the context (it will
            // be used to limit its computation)
            $currentCondition = null;
            $currentOnlyIf = null;
            $currentOnlyIfNot = null;
            $previousStoreKey = null;
            $pendingStoreKey = end($pendingStoreKeysStack);
 
            if ($this->branchPruningEnabled) {
                // this is a condition ?
                if (isset($expectingConditionMap[$pendingStoreKey]) && $expectingConditionMap[$pendingStoreKey]) {
                    $currentCondition = $pendingStoreKey;
                    $stackDepth = count($pendingStoreKeysStack);
                    if ($stackDepth > 1) { // nested if
                        $previousStoreKey = $pendingStoreKeysStack[$stackDepth - 2];
                    }
                }
                if (isset($expectingThenMap[$pendingStoreKey]) && $expectingThenMap[$pendingStoreKey]) {
                    $currentOnlyIf = $pendingStoreKey;
                } elseif (isset($previousStoreKey)) {
                    if (isset($expectingThenMap[$previousStoreKey]) && $expectingThenMap[$previousStoreKey]) {
                        $currentOnlyIf = $previousStoreKey;
                    }
                }
                if (isset($expectingElseMap[$pendingStoreKey]) && $expectingElseMap[$pendingStoreKey]) {
                    $currentOnlyIfNot = $pendingStoreKey;
                } elseif (isset($previousStoreKey)) {
                    if (isset($expectingElseMap[$previousStoreKey]) && $expectingElseMap[$previousStoreKey]) {
                        $currentOnlyIfNot = $previousStoreKey;
                    }
                }
            }
 
            $opCharacter = $formula[$index]; //    Get the first character of the value at the current index position
 
            if ((isset(self::$comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset(self::$comparisonOperators[$formula[$index + 1]]))) {
                $opCharacter .= $formula[++$index];
            }
            //    Find out if we're currently at the beginning of a number, variable, cell reference, function, parenthesis or operand
            $isOperandOrFunction = (bool) preg_match($regexpMatchString, substr($formula, $index), $match);
 
            if ($opCharacter == '-' && !$expectingOperator) {                //    Is it a negation instead of a minus?
                //    Put a negation on the stack
                $stack->push('Unary Operator', '~', null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                ++$index; //        and drop the negation symbol
            } elseif ($opCharacter == '%' && $expectingOperator) {
                //    Put a percentage on the stack
                $stack->push('Unary Operator', '%', null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                ++$index;
            } elseif ($opCharacter == '+' && !$expectingOperator) {            //    Positive (unary plus rather than binary operator plus) can be discarded?
                ++$index; //    Drop the redundant plus symbol
            } elseif ((($opCharacter == '~') || ($opCharacter == '|')) && (!$isOperandOrFunction)) {    //    We have to explicitly deny a tilde or pipe, because they are legal
                return $this->raiseFormulaError("Formula Error: Illegal character '~'"); //        on the stack but not in the input expression
            } elseif ((isset(self::$operators[$opCharacter]) || $isOperandOrFunction) && $expectingOperator) {    //    Are we putting an operator on the stack?
                while (
                    $stack->count() > 0 &&
                    ($o2 = $stack->last()) &&
                    isset(self::$operators[$o2['value']]) &&
                    @(self::$operatorAssociativity[$opCharacter] ? self::$operatorPrecedence[$opCharacter] < self::$operatorPrecedence[$o2['value']] : self::$operatorPrecedence[$opCharacter] <= self::$operatorPrecedence[$o2['value']])
                ) {
                    $output[] = $stack->pop(); //    Swap operands and higher precedence operators from the stack to the output
                }
 
                //    Finally put our current operator onto the stack
                $stack->push('Binary Operator', $opCharacter, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
 
                ++$index;
                $expectingOperator = false;
            } elseif ($opCharacter == ')' && $expectingOperator) {            //    Are we expecting to close a parenthesis?
                $expectingOperand = false;
                while (($o2 = $stack->pop()) && $o2['value'] != '(') {        //    Pop off the stack back to the last (
                    if ($o2 === null) {
                        return $this->raiseFormulaError('Formula Error: Unexpected closing brace ")"');
                    }
                    $output[] = $o2;
                }
                $d = $stack->last(2);
 
                // Branch pruning we decrease the depth whether is it a function
                // call or a parenthesis
                if (!empty($pendingStoreKey)) {
                    --$parenthesisDepthMap[$pendingStoreKey];
                }
 
                if (is_array($d) && preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $d['value'], $matches)) {    //    Did this parenthesis just close a function?
                    if (!empty($pendingStoreKey) && $parenthesisDepthMap[$pendingStoreKey] == -1) {
                        // we are closing an IF(
                        if ($d['value'] != 'IF(') {
                            return $this->raiseFormulaError('Parser bug we should be in an "IF("');
                        }
                        if ($expectingConditionMap[$pendingStoreKey]) {
                            return $this->raiseFormulaError('We should not be expecting a condition');
                        }
                        $expectingThenMap[$pendingStoreKey] = false;
                        $expectingElseMap[$pendingStoreKey] = false;
                        --$parenthesisDepthMap[$pendingStoreKey];
                        array_pop($pendingStoreKeysStack);
                        unset($pendingStoreKey);
                    }
 
                    $functionName = $matches[1]; //    Get the function name
                    $d = $stack->pop();
                    $argumentCount = $d['value']; //    See how many arguments there were (argument count is the next value stored on the stack)
                    $output[] = $d; //    Dump the argument count on the output
                    $output[] = $stack->pop(); //    Pop the function and push onto the output
                    if (isset(self::$controlFunctions[$functionName])) {
                        $expectedArgumentCount = self::$controlFunctions[$functionName]['argumentCount'];
                        $functionCall = self::$controlFunctions[$functionName]['functionCall'];
                    } elseif (isset(self::$phpSpreadsheetFunctions[$functionName])) {
                        $expectedArgumentCount = self::$phpSpreadsheetFunctions[$functionName]['argumentCount'];
                        $functionCall = self::$phpSpreadsheetFunctions[$functionName]['functionCall'];
                    } else {    // did we somehow push a non-function on the stack? this should never happen
                        return $this->raiseFormulaError('Formula Error: Internal error, non-function on stack');
                    }
                    //    Check the argument count
                    $argumentCountError = false;
                    $expectedArgumentCountString = null;
                    if (is_numeric($expectedArgumentCount)) {
                        if ($expectedArgumentCount < 0) {
                            if ($argumentCount > abs($expectedArgumentCount)) {
                                $argumentCountError = true;
                                $expectedArgumentCountString = 'no more than ' . abs($expectedArgumentCount);
                            }
                        } else {
                            if ($argumentCount != $expectedArgumentCount) {
                                $argumentCountError = true;
                                $expectedArgumentCountString = $expectedArgumentCount;
                            }
                        }
                    } elseif ($expectedArgumentCount != '*') {
                        $isOperandOrFunction = preg_match('/(\d*)([-+,])(\d*)/', $expectedArgumentCount, $argMatch);
                        switch ($argMatch[2]) {
                            case '+':
                                if ($argumentCount < $argMatch[1]) {
                                    $argumentCountError = true;
                                    $expectedArgumentCountString = $argMatch[1] . ' or more ';
                                }
 
                                break;
                            case '-':
                                if (($argumentCount < $argMatch[1]) || ($argumentCount > $argMatch[3])) {
                                    $argumentCountError = true;
                                    $expectedArgumentCountString = 'between ' . $argMatch[1] . ' and ' . $argMatch[3];
                                }
 
                                break;
                            case ',':
                                if (($argumentCount != $argMatch[1]) && ($argumentCount != $argMatch[3])) {
                                    $argumentCountError = true;
                                    $expectedArgumentCountString = 'either ' . $argMatch[1] . ' or ' . $argMatch[3];
                                }
 
                                break;
                        }
                    }
                    if ($argumentCountError) {
                        return $this->raiseFormulaError("Formula Error: Wrong number of arguments for $functionName() function: $argumentCount given, " . $expectedArgumentCountString . ' expected');
                    }
                }
                ++$index;
            } elseif ($opCharacter == ',') {            //    Is this the separator for function arguments?
                if (
                    !empty($pendingStoreKey) &&
                    $parenthesisDepthMap[$pendingStoreKey] == 0
                ) {
                    // We must go to the IF next argument
                    if ($expectingConditionMap[$pendingStoreKey]) {
                        $expectingConditionMap[$pendingStoreKey] = false;
                        $expectingThenMap[$pendingStoreKey] = true;
                    } elseif ($expectingThenMap[$pendingStoreKey]) {
                        $expectingThenMap[$pendingStoreKey] = false;
                        $expectingElseMap[$pendingStoreKey] = true;
                    } elseif ($expectingElseMap[$pendingStoreKey]) {
                        return $this->raiseFormulaError('Reaching fourth argument of an IF');
                    }
                }
                while (($o2 = $stack->pop()) && $o2['value'] != '(') {        //    Pop off the stack back to the last (
                    if ($o2 === null) {
                        return $this->raiseFormulaError('Formula Error: Unexpected ,');
                    }
                    $output[] = $o2; // pop the argument expression stuff and push onto the output
                }
                //    If we've a comma when we're expecting an operand, then what we actually have is a null operand;
                //        so push a null onto the stack
                if (($expectingOperand) || (!$expectingOperator)) {
                    $output[] = ['type' => 'NULL Value', 'value' => self::$excelConstants['NULL'], 'reference' => null];
                }
                // make sure there was a function
                $d = $stack->last(2);
                if (!preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $d['value'], $matches)) {
                    return $this->raiseFormulaError('Formula Error: Unexpected ,');
                }
                $d = $stack->pop();
                $itemStoreKey = $d['storeKey'] ?? null;
                $itemOnlyIf = $d['onlyIf'] ?? null;
                $itemOnlyIfNot = $d['onlyIfNot'] ?? null;
                $stack->push($d['type'], ++$d['value'], $d['reference'], $itemStoreKey, $itemOnlyIf, $itemOnlyIfNot); // increment the argument count
                $stack->push('Brace', '(', null, $itemStoreKey, $itemOnlyIf, $itemOnlyIfNot); // put the ( back on, we'll need to pop back to it again
                $expectingOperator = false;
                $expectingOperand = true;
                ++$index;
            } elseif ($opCharacter == '(' && !$expectingOperator) {
                if (!empty($pendingStoreKey)) { // Branch pruning: we go deeper
                    ++$parenthesisDepthMap[$pendingStoreKey];
                }
                $stack->push('Brace', '(', null, $currentCondition, $currentOnlyIf, $currentOnlyIf);
                ++$index;
            } elseif ($isOperandOrFunction && !$expectingOperator) {    // do we now have a function/variable/number?
                $expectingOperator = true;
                $expectingOperand = false;
                $val = $match[1];
                $length = strlen($val);
 
                if (preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $val, $matches)) {
                    $val = preg_replace('/\s/u', '', $val);
                    if (isset(self::$phpSpreadsheetFunctions[strtoupper($matches[1])]) || isset(self::$controlFunctions[strtoupper($matches[1])])) {    // it's a function
                        $valToUpper = strtoupper($val);
                    } else {
                        $valToUpper = 'NAME.ERROR(';
                    }
                    // here $matches[1] will contain values like "IF"
                    // and $val "IF("
                    if ($this->branchPruningEnabled && ($valToUpper == 'IF(')) { // we handle a new if
                        $pendingStoreKey = $this->getUnusedBranchStoreKey();
                        $pendingStoreKeysStack[] = $pendingStoreKey;
                        $expectingConditionMap[$pendingStoreKey] = true;
                        $parenthesisDepthMap[$pendingStoreKey] = 0;
                    } else { // this is not an if but we go deeper
                        if (!empty($pendingStoreKey) && array_key_exists($pendingStoreKey, $parenthesisDepthMap)) {
                            ++$parenthesisDepthMap[$pendingStoreKey];
                        }
                    }
 
                    $stack->push('Function', $valToUpper, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                    // tests if the function is closed right after opening
                    $ax = preg_match('/^\s*\‍)/u', substr($formula, $index + $length));
                    if ($ax) {
                        $stack->push('Operand Count for Function ' . $valToUpper . ')', 0, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                        $expectingOperator = true;
                    } else {
                        $stack->push('Operand Count for Function ' . $valToUpper . ')', 1, null, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                        $expectingOperator = false;
                    }
                    $stack->push('Brace', '(');
                } elseif (preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $val, $matches)) {
                    //    Watch for this case-change when modifying to allow cell references in different worksheets...
                    //    Should only be applied to the actual cell column, not the worksheet name
                    //    If the last entry on the stack was a : operator, then we have a cell range reference
                    $testPrevOp = $stack->last(1);
                    if ($testPrevOp !== null && $testPrevOp['value'] === ':') {
                        //    If we have a worksheet reference, then we're playing with a 3D reference
                        if ($matches[2] == '') {
                            //    Otherwise, we 'inherit' the worksheet reference from the start cell reference
                            //    The start of the cell range reference should be the last entry in $output
                            $rangeStartCellRef = $output[count($output) - 1]['value'];
                            preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $rangeStartCellRef, $rangeStartMatches);
                            if ($rangeStartMatches[2] > '') {
                                $val = $rangeStartMatches[2] . '!' . $val;
                            }
                        } else {
                            $rangeStartCellRef = $output[count($output) - 1]['value'];
                            preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $rangeStartCellRef, $rangeStartMatches);
                            if ($rangeStartMatches[2] !== $matches[2]) {
                                return $this->raiseFormulaError('3D Range references are not yet supported');
                            }
                        }
                    } elseif (strpos($val, '!') === false && $pCellParent !== null) {
                        $worksheet = $pCellParent->getTitle();
                        $val = "'{$worksheet}'!{$val}";
                    }
 
                    $outputItem = $stack->getStackItem('Cell Reference', $val, $val, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
 
                    $output[] = $outputItem;
                } else {    // it's a variable, constant, string, number or boolean
                    $localeConstant = false;
                    $stackItemType = 'Value';
                    $stackItemReference = null;
 
                    //    If the last entry on the stack was a : operator, then we may have a row or column range reference
                    $testPrevOp = $stack->last(1);
                    if ($testPrevOp !== null && $testPrevOp['value'] === ':') {
                        $stackItemType = 'Cell Reference';
                        $startRowColRef = $output[count($output) - 1]['value'];
                        [$rangeWS1, $startRowColRef] = Worksheet::extractSheetTitle($startRowColRef, true);
                        $rangeSheetRef = $rangeWS1;
                        if ($rangeWS1 !== '') {
                            $rangeWS1 .= '!';
                        }
                        $rangeSheetRef = trim($rangeSheetRef, "'");
                        [$rangeWS2, $val] = Worksheet::extractSheetTitle($val, true);
                        if ($rangeWS2 !== '') {
                            $rangeWS2 .= '!';
                        } else {
                            $rangeWS2 = $rangeWS1;
                        }
 
                        $refSheet = $pCellParent;
                        if ($pCellParent !== null && $rangeSheetRef !== '' && $rangeSheetRef !== $pCellParent->getTitle()) {
                            $refSheet = $pCellParent->getParent()->getSheetByName($rangeSheetRef);
                        }
 
                        if (ctype_digit($val) && $val <= 1048576) {
                            //    Row range
                            $stackItemType = 'Row Reference';
                            $endRowColRef = ($refSheet !== null) ? $refSheet->getHighestDataColumn($val) : 'XFD'; //    Max 16,384 columns for Excel2007
                            $val = "{$rangeWS2}{$endRowColRef}{$val}";
                        } elseif (ctype_alpha($val) && strlen($val) <= 3) {
                            //    Column range
                            $stackItemType = 'Column Reference';
                            $endRowColRef = ($refSheet !== null) ? $refSheet->getHighestDataRow($val) : 1048576; //    Max 1,048,576 rows for Excel2007
                            $val = "{$rangeWS2}{$val}{$endRowColRef}";
                        }
                        $stackItemReference = $val;
                    } elseif ($opCharacter == self::FORMULA_STRING_QUOTE) {
                        //    UnEscape any quotes within the string
                        $val = self::wrapResult(str_replace('""', self::FORMULA_STRING_QUOTE, self::unwrapResult($val)));
                    } elseif (isset(self::$excelConstants[trim(strtoupper($val))])) {
                        $stackItemType = 'Constant';
                        $excelConstant = trim(strtoupper($val));
                        $val = self::$excelConstants[$excelConstant];
                    } elseif (($localeConstant = array_search(trim(strtoupper($val)), self::$localeBoolean)) !== false) {
                        $stackItemType = 'Constant';
                        $val = self::$excelConstants[$localeConstant];
                    } elseif (
                        preg_match('/^' . self::CALCULATION_REGEXP_ROW_RANGE . '/miu', substr($formula, $index), $rowRangeReference)
                    ) {
                        $val = $rowRangeReference[1];
                        $length = strlen($rowRangeReference[1]);
                        $stackItemType = 'Row Reference';
                        $column = 'A';
                        if (($testPrevOp !== null && $testPrevOp['value'] === ':') && $pCellParent !== null) {
                            $column = $pCellParent->getHighestDataColumn($val);
                        }
                        $val = "{$rowRangeReference[2]}{$column}{$rowRangeReference[7]}";
                        $stackItemReference = $val;
                    } elseif (
                        preg_match('/^' . self::CALCULATION_REGEXP_COLUMN_RANGE . '/miu', substr($formula, $index), $columnRangeReference)
                    ) {
                        $val = $columnRangeReference[1];
                        $length = strlen($val);
                        $stackItemType = 'Column Reference';
                        $row = '1';
                        if (($testPrevOp !== null && $testPrevOp['value'] === ':') && $pCellParent !== null) {
                            $row = $pCellParent->getHighestDataRow($val);
                        }
                        $val = "{$val}{$row}";
                        $stackItemReference = $val;
                    } elseif (preg_match('/^' . self::CALCULATION_REGEXP_DEFINEDNAME . '.*/miu', $val, $match)) {
                        $stackItemType = 'Defined Name';
                        $stackItemReference = $val;
                    } elseif (is_numeric($val)) {
                        if ((strpos($val, '.') !== false) || (stripos($val, 'e') !== false) || ($val > PHP_INT_MAX) || ($val < -PHP_INT_MAX)) {
                            $val = (float) $val;
                        } else {
                            $val = (int) $val;
                        }
                    }
 
                    $details = $stack->getStackItem($stackItemType, $val, $stackItemReference, $currentCondition, $currentOnlyIf, $currentOnlyIfNot);
                    if ($localeConstant) {
                        $details['localeValue'] = $localeConstant;
                    }
                    $output[] = $details;
                }
                $index += $length;
            } elseif ($opCharacter == '$') {    // absolute row or column range
                ++$index;
            } elseif ($opCharacter == ')') {    // miscellaneous error checking
                if ($expectingOperand) {
                    $output[] = ['type' => 'NULL Value', 'value' => self::$excelConstants['NULL'], 'reference' => null];
                    $expectingOperand = false;
                    $expectingOperator = true;
                } else {
                    return $this->raiseFormulaError("Formula Error: Unexpected ')'");
                }
            } elseif (isset(self::$operators[$opCharacter]) && !$expectingOperator) {
                return $this->raiseFormulaError("Formula Error: Unexpected operator '$opCharacter'");
            } else {    // I don't even want to know what you did to get here
                return $this->raiseFormulaError('Formula Error: An unexpected error occurred');
            }
            //    Test for end of formula string
            if ($index == strlen($formula)) {
                //    Did we end with an operator?.
                //    Only valid for the % unary operator
                if ((isset(self::$operators[$opCharacter])) && ($opCharacter != '%')) {
                    return $this->raiseFormulaError("Formula Error: Operator '$opCharacter' has no operands");
                }
 
                break;
            }
            //    Ignore white space
            while (($formula[$index] == "\n") || ($formula[$index] == "\r")) {
                ++$index;
            }
 
            if ($formula[$index] == ' ') {
                while ($formula[$index] == ' ') {
                    ++$index;
                }
 
                //    If we're expecting an operator, but only have a space between the previous and next operands (and both are
                //        Cell References) then we have an INTERSECTION operator
                if (
                    ($expectingOperator) &&
                    ((preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '.*/Ui', substr($formula, $index), $match)) &&
                        ($output[count($output) - 1]['type'] == 'Cell Reference') ||
                        (preg_match('/^' . self::CALCULATION_REGEXP_DEFINEDNAME . '.*/miu', substr($formula, $index), $match)) &&
                        ($output[count($output) - 1]['type'] == 'Defined Name' || $output[count($output) - 1]['type'] == 'Value')
                    )
                ) {
                    while (
                        $stack->count() > 0 &&
                        ($o2 = $stack->last()) &&
                        isset(self::$operators[$o2['value']]) &&
                        @(self::$operatorAssociativity[$opCharacter] ? self::$operatorPrecedence[$opCharacter] < self::$operatorPrecedence[$o2['value']] : self::$operatorPrecedence[$opCharacter] <= self::$operatorPrecedence[$o2['value']])
                    ) {
                        $output[] = $stack->pop(); //    Swap operands and higher precedence operators from the stack to the output
                    }
                    $stack->push('Binary Operator', '|'); //    Put an Intersect Operator on the stack
                    $expectingOperator = false;
                }
            }
        }
 
        while (($op = $stack->pop()) !== null) {    // pop everything off the stack and push onto output
            if ((is_array($op) && $op['value'] == '(') || ($op === '(')) {
                return $this->raiseFormulaError("Formula Error: Expecting ')'"); // if there are any opening braces on the stack, then braces were unbalanced
            }
            $output[] = $op;
        }
 
        return $output;
    }

References $d, $index, Sabre\VObject\$output, $row, PhpOffice\PhpSpreadsheet\Calculation\Calculation\convertMatrixReferences(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\getUnusedBranchStoreKey(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\raiseFormulaError(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\wrapResult().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\parseFormula().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isImplemented()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::isImplemented ( $pFunction )

Is a specific function implemented?

Parameters

string $pFunction Function Name

Returns: bool

Definition at line 5356 of file Calculation.php.

    {
        $pFunction = strtoupper($pFunction);
        $notImplemented = !isset(self::$phpSpreadsheetFunctions[$pFunction]) || (is_array(self::$phpSpreadsheetFunctions[$pFunction]['functionCall']) && self::$phpSpreadsheetFunctions[$pFunction]['functionCall'][1] === 'DUMMY');
 
        return !$notImplemented;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getImplementedFunctionNames().

Here is the caller graph for this function:

◆ loadLocales()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::loadLocales ( )

staticprivate

Definition at line 2768 of file Calculation.php.

                                         : void
    {
        $localeFileDirectory = __DIR__ . '/locale/';
        foreach (glob($localeFileDirectory . '*', GLOB_ONLYDIR) as $filename) {
            $filename = substr($filename, strlen($localeFileDirectory));
            if ($filename != 'en') {
                self::$validLocaleLanguages[] = $filename;
            }
        }
    }

References $filename.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\setLocale().

Here is the caller graph for this function:

◆ localeFunc()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::localeFunc ( $function )

static

Definition at line 3220 of file Calculation.php.

    {
        if (self::$localeLanguage !== 'en_us') {
            $functionName = trim($function, '(');
            if (isset(self::$localeFunctions[$functionName])) {
                $brace = ($functionName != $function);
                $function = self::$localeFunctions[$functionName];
                if ($brace) {
                    $function .= '(';
                }
            }
        }
 
        return $function;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Token\Stack\push().

Here is the caller graph for this function:

◆ parseFormula()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::parseFormula ( $formula )

Validate and parse a formula string.

Parameters

string $formula Formula to parse

Returns: array|bool

Definition at line 3384 of file Calculation.php.

    {
        //    Basic validation that this is indeed a formula
        //    We return an empty array if not
        $formula = trim($formula);
        if ((!isset($formula[0])) || ($formula[0] != '=')) {
            return [];
        }
        $formula = ltrim(substr($formula, 1));
        if (!isset($formula[0])) {
            return [];
        }
 
        //    Parse the formula and return the token stack
        return $this->internalParseFormula($formula);
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula().

Here is the call graph for this function:

◆ processTokenStack()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::processTokenStack	(		$tokens,
			$cellID = `null`,
		?Cell	$pCell = `null`
	)

private

Parameters

mixed	$tokens
null \| string	$cellID

Returns: array<int, mixed>|false

Definition at line 4385 of file Calculation.php.

    {
        if ($tokens == false) {
            return false;
        }
 
        //    If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent cell collection),
        //        so we store the parent cell collection so that we can re-attach it when necessary
        $pCellWorksheet = ($pCell !== null) ? $pCell->getWorksheet() : null;
        $pCellParent = ($pCell !== null) ? $pCell->getParent() : null;
        $stack = new Stack();
 
        // Stores branches that have been pruned
        $fakedForBranchPruning = [];
        // help us to know when pruning ['branchTestId' => true/false]
        $branchStore = [];
        //    Loop through each token in turn
        foreach ($tokens as $tokenData) {
            $token = $tokenData['value'];
 
            // Branch pruning: skip useless resolutions
            $storeKey = $tokenData['storeKey'] ?? null;
            if ($this->branchPruningEnabled && isset($tokenData['onlyIf'])) {
                $onlyIfStoreKey = $tokenData['onlyIf'];
                $storeValue = $branchStore[$onlyIfStoreKey] ?? null;
                $storeValueAsBool = ($storeValue === null) ?
                    true : (bool) Functions::flattenSingleValue($storeValue);
                if (is_array($storeValue)) {
                    $wrappedItem = end($storeValue);
                    $storeValue = end($wrappedItem);
                }
 
                if (
                    isset($storeValue)
                    && (
                        !$storeValueAsBool
                        || Functions::isError($storeValue)
                        || ($storeValue === 'Pruned branch')
                    )
                ) {
                    // If branching value is not true, we don't need to compute
                    if (!isset($fakedForBranchPruning['onlyIf-' . $onlyIfStoreKey])) {
                        $stack->push('Value', 'Pruned branch (only if ' . $onlyIfStoreKey . ') ' . $token);
                        $fakedForBranchPruning['onlyIf-' . $onlyIfStoreKey] = true;
                    }
 
                    if (isset($storeKey)) {
                        // We are processing an if condition
                        // We cascade the pruning to the depending branches
                        $branchStore[$storeKey] = 'Pruned branch';
                        $fakedForBranchPruning['onlyIfNot-' . $storeKey] = true;
                        $fakedForBranchPruning['onlyIf-' . $storeKey] = true;
                    }
 
                    continue;
                }
            }
 
            if ($this->branchPruningEnabled && isset($tokenData['onlyIfNot'])) {
                $onlyIfNotStoreKey = $tokenData['onlyIfNot'];
                $storeValue = $branchStore[$onlyIfNotStoreKey] ?? null;
                $storeValueAsBool = ($storeValue === null) ?
                    true : (bool) Functions::flattenSingleValue($storeValue);
                if (is_array($storeValue)) {
                    $wrappedItem = end($storeValue);
                    $storeValue = end($wrappedItem);
                }
                if (
                    isset($storeValue)
                    && (
                        $storeValueAsBool
                        || Functions::isError($storeValue)
                        || ($storeValue === 'Pruned branch'))
                ) {
                    // If branching value is true, we don't need to compute
                    if (!isset($fakedForBranchPruning['onlyIfNot-' . $onlyIfNotStoreKey])) {
                        $stack->push('Value', 'Pruned branch (only if not ' . $onlyIfNotStoreKey . ') ' . $token);
                        $fakedForBranchPruning['onlyIfNot-' . $onlyIfNotStoreKey] = true;
                    }
 
                    if (isset($storeKey)) {
                        // We are processing an if condition
                        // We cascade the pruning to the depending branches
                        $branchStore[$storeKey] = 'Pruned branch';
                        $fakedForBranchPruning['onlyIfNot-' . $storeKey] = true;
                        $fakedForBranchPruning['onlyIf-' . $storeKey] = true;
                    }
 
                    continue;
                }
            }
 
            // if the token is a binary operator, pop the top two values off the stack, do the operation, and push the result back on the stack
            if (isset(self::$binaryOperators[$token])) {
                //    We must have two operands, error if we don't
                if (($operand2Data = $stack->pop()) === null) {
                    return $this->raiseFormulaError('Internal error - Operand value missing from stack');
                }
                if (($operand1Data = $stack->pop()) === null) {
                    return $this->raiseFormulaError('Internal error - Operand value missing from stack');
                }
 
                $operand1 = self::dataTestReference($operand1Data);
                $operand2 = self::dataTestReference($operand2Data);
 
                //    Log what we're doing
                if ($token == ':') {
                    $this->debugLog->writeDebugLog('Evaluating Range ', $this->showValue($operand1Data['reference']), ' ', $token, ' ', $this->showValue($operand2Data['reference']));
                } else {
                    $this->debugLog->writeDebugLog('Evaluating ', $this->showValue($operand1), ' ', $token, ' ', $this->showValue($operand2));
                }
 
                //    Process the operation in the appropriate manner
                switch ($token) {
                    //    Comparison (Boolean) Operators
                    case '>':            //    Greater than
                    case '<':            //    Less than
                    case '>=':            //    Greater than or Equal to
                    case '<=':            //    Less than or Equal to
                    case '=':            //    Equality
                    case '<>':            //    Inequality
                        $result = $this->executeBinaryComparisonOperation($cellID, $operand1, $operand2, $token, $stack);
                        if (isset($storeKey)) {
                            $branchStore[$storeKey] = $result;
                        }
 
                        break;
                    //    Binary Operators
                    case ':':            //    Range
                        if (strpos($operand1Data['reference'], '!') !== false) {
                            [$sheet1, $operand1Data['reference']] = Worksheet::extractSheetTitle($operand1Data['reference'], true);
                        } else {
                            $sheet1 = ($pCellParent !== null) ? $pCellWorksheet->getTitle() : '';
                        }
 
                        [$sheet2, $operand2Data['reference']] = Worksheet::extractSheetTitle($operand2Data['reference'], true);
                        if (empty($sheet2)) {
                            $sheet2 = $sheet1;
                        }
 
                        if ($sheet1 == $sheet2) {
                            if ($operand1Data['reference'] === null) {
                                if ((trim($operand1Data['value']) != '') && (is_numeric($operand1Data['value']))) {
                                    $operand1Data['reference'] = $pCell->getColumn() . $operand1Data['value'];
                                } elseif (trim($operand1Data['reference']) == '') {
                                    $operand1Data['reference'] = $pCell->getCoordinate();
                                } else {
                                    $operand1Data['reference'] = $operand1Data['value'] . $pCell->getRow();
                                }
                            }
                            if ($operand2Data['reference'] === null) {
                                if ((trim($operand2Data['value']) != '') && (is_numeric($operand2Data['value']))) {
                                    $operand2Data['reference'] = $pCell->getColumn() . $operand2Data['value'];
                                } elseif (trim($operand2Data['reference']) == '') {
                                    $operand2Data['reference'] = $pCell->getCoordinate();
                                } else {
                                    $operand2Data['reference'] = $operand2Data['value'] . $pCell->getRow();
                                }
                            }
 
                            $oData = array_merge(explode(':', $operand1Data['reference']), explode(':', $operand2Data['reference']));
                            $oCol = $oRow = [];
                            foreach ($oData as $oDatum) {
                                $oCR = Coordinate::coordinateFromString($oDatum);
                                $oCol[] = Coordinate::columnIndexFromString($oCR[0]) - 1;
                                $oRow[] = $oCR[1];
                            }
                            $cellRef = Coordinate::stringFromColumnIndex(min($oCol) + 1) . min($oRow) . ':' . Coordinate::stringFromColumnIndex(max($oCol) + 1) . max($oRow);
                            if ($pCellParent !== null) {
                                $cellValue = $this->extractCellRange($cellRef, $this->spreadsheet->getSheetByName($sheet1), false);
                            } else {
                                return $this->raiseFormulaError('Unable to access Cell Reference');
                            }
 
                            $stack->push('Cell Reference', $cellValue, $cellRef);
                        } else {
                            $stack->push('Error', Functions::REF(), null);
                        }
 
                        break;
                    case '+':            //    Addition
                        $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'plusEquals', $stack);
                        if (isset($storeKey)) {
                            $branchStore[$storeKey] = $result;
                        }
 
                        break;
                    case '-':            //    Subtraction
                        $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'minusEquals', $stack);
                        if (isset($storeKey)) {
                            $branchStore[$storeKey] = $result;
                        }
 
                        break;
                    case '*':            //    Multiplication
                        $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'arrayTimesEquals', $stack);
                        if (isset($storeKey)) {
                            $branchStore[$storeKey] = $result;
                        }
 
                        break;
                    case '/':            //    Division
                        $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'arrayRightDivide', $stack);
                        if (isset($storeKey)) {
                            $branchStore[$storeKey] = $result;
                        }
 
                        break;
                    case '^':            //    Exponential
                        $result = $this->executeNumericBinaryOperation($operand1, $operand2, $token, 'power', $stack);
                        if (isset($storeKey)) {
                            $branchStore[$storeKey] = $result;
                        }
 
                        break;
                    case '&':            //    Concatenation
                        //    If either of the operands is a matrix, we need to treat them both as matrices
                        //        (converting the other operand to a matrix if need be); then perform the required
                        //        matrix operation
                        if (is_bool($operand1)) {
                            $operand1 = ($operand1) ? self::$localeBoolean['TRUE'] : self::$localeBoolean['FALSE'];
                        }
                        if (is_bool($operand2)) {
                            $operand2 = ($operand2) ? self::$localeBoolean['TRUE'] : self::$localeBoolean['FALSE'];
                        }
                        if ((is_array($operand1)) || (is_array($operand2))) {
                            //    Ensure that both operands are arrays/matrices
                            self::checkMatrixOperands($operand1, $operand2, 2);
 
                            try {
                                //    Convert operand 1 from a PHP array to a matrix
                                $matrix = new Shared\JAMA\Matrix($operand1);
                                //    Perform the required operation against the operand 1 matrix, passing in operand 2
                                $matrixResult = $matrix->concat($operand2);
                                $result = $matrixResult->getArray();
                            } catch (\Exception $ex) {
                                $this->debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                                $result = '#VALUE!';
                            }
                        } else {
                            $result = self::FORMULA_STRING_QUOTE . str_replace('""', self::FORMULA_STRING_QUOTE, self::unwrapResult($operand1) . self::unwrapResult($operand2)) . self::FORMULA_STRING_QUOTE;
                        }
                        $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
                        $stack->push('Value', $result);
 
                        if (isset($storeKey)) {
                            $branchStore[$storeKey] = $result;
                        }
 
                        break;
                    case '|':            //    Intersect
                        $rowIntersect = array_intersect_key($operand1, $operand2);
                        $cellIntersect = $oCol = $oRow = [];
                        foreach (array_keys($rowIntersect) as $row) {
                            $oRow[] = $row;
                            foreach ($rowIntersect[$row] as $col => $data) {
                                $oCol[] = Coordinate::columnIndexFromString($col) - 1;
                                $cellIntersect[$row] = array_intersect_key($operand1[$row], $operand2[$row]);
                            }
                        }
                        if (count(Functions::flattenArray($cellIntersect)) === 0) {
                            $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($cellIntersect));
                            $stack->push('Error', Functions::null(), null);
                        } else {
                            $cellRef = Coordinate::stringFromColumnIndex(min($oCol) + 1) . min($oRow) . ':' .
                                Coordinate::stringFromColumnIndex(max($oCol) + 1) . max($oRow);
                            $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($cellIntersect));
                            $stack->push('Value', $cellIntersect, $cellRef);
                        }
 
                        break;
                }
 
                // if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
            } elseif (($token === '~') || ($token === '%')) {
                if (($arg = $stack->pop()) === null) {
                    return $this->raiseFormulaError('Internal error - Operand value missing from stack');
                }
                $arg = $arg['value'];
                if ($token === '~') {
                    $this->debugLog->writeDebugLog('Evaluating Negation of ', $this->showValue($arg));
                    $multiplier = -1;
                } else {
                    $this->debugLog->writeDebugLog('Evaluating Percentile of ', $this->showValue($arg));
                    $multiplier = 0.01;
                }
                if (is_array($arg)) {
                    self::checkMatrixOperands($arg, $multiplier, 2);
 
                    try {
                        $matrix1 = new Shared\JAMA\Matrix($arg);
                        $matrixResult = $matrix1->arrayTimesEquals($multiplier);
                        $result = $matrixResult->getArray();
                    } catch (\Exception $ex) {
                        $this->debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                        $result = '#VALUE!';
                    }
                    $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($result));
                    $stack->push('Value', $result);
                    if (isset($storeKey)) {
                        $branchStore[$storeKey] = $result;
                    }
                } else {
                    $this->executeNumericBinaryOperation($multiplier, $arg, '*', 'arrayTimesEquals', $stack);
                }
            } elseif (preg_match('/^' . self::CALCULATION_REGEXP_CELLREF . '$/i', $token ?? '', $matches)) {
                $cellRef = null;
 
                if (isset($matches[8])) {
                    if ($pCell === null) {
                        //                        We can't access the range, so return a REF error
                        $cellValue = Functions::REF();
                    } else {
                        $cellRef = $matches[6] . $matches[7] . ':' . $matches[9] . $matches[10];
                        if ($matches[2] > '') {
                            $matches[2] = trim($matches[2], "\"'");
                            if ((strpos($matches[2], '[') !== false) || (strpos($matches[2], ']') !== false)) {
                                //    It's a Reference to an external spreadsheet (not currently supported)
                                return $this->raiseFormulaError('Unable to access External Workbook');
                            }
                            $matches[2] = trim($matches[2], "\"'");
                            $this->debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in worksheet ', $matches[2]);
                            if ($pCellParent !== null) {
                                $cellValue = $this->extractCellRange($cellRef, $this->spreadsheet->getSheetByName($matches[2]), false);
                            } else {
                                return $this->raiseFormulaError('Unable to access Cell Reference');
                            }
                            $this->debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->showTypeDetails($cellValue));
                        } else {
                            $this->debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in current worksheet');
                            if ($pCellParent !== null) {
                                $cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, false);
                            } else {
                                return $this->raiseFormulaError('Unable to access Cell Reference');
                            }
                            $this->debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' is ', $this->showTypeDetails($cellValue));
                        }
                    }
                } else {
                    if ($pCell === null) {
                        //  We can't access the cell, so return a REF error
                        $cellValue = Functions::REF();
                    } else {
                        $cellRef = $matches[6] . $matches[7];
                        if ($matches[2] > '') {
                            $matches[2] = trim($matches[2], "\"'");
                            if ((strpos($matches[2], '[') !== false) || (strpos($matches[2], ']') !== false)) {
                                //    It's a Reference to an external spreadsheet (not currently supported)
                                return $this->raiseFormulaError('Unable to access External Workbook');
                            }
                            $this->debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in worksheet ', $matches[2]);
                            if ($pCellParent !== null) {
                                $cellSheet = $this->spreadsheet->getSheetByName($matches[2]);
                                if ($cellSheet && $cellSheet->cellExists($cellRef)) {
                                    $cellValue = $this->extractCellRange($cellRef, $this->spreadsheet->getSheetByName($matches[2]), false);
                                    $pCell->attach($pCellParent);
                                } else {
                                    $cellRef = ($cellSheet !== null) ? "{$matches[2]}!{$cellRef}" : $cellRef;
                                    $cellValue = null;
                                }
                            } else {
                                return $this->raiseFormulaError('Unable to access Cell Reference');
                            }
                            $this->debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->showTypeDetails($cellValue));
                        } else {
                            $this->debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in current worksheet');
                            if ($pCellParent->has($cellRef)) {
                                $cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, false);
                                $pCell->attach($pCellParent);
                            } else {
                                $cellValue = null;
                            }
                            $this->debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' is ', $this->showTypeDetails($cellValue));
                        }
                    }
                }
 
                $stack->push('Cell Value', $cellValue, $cellRef);
                if (isset($storeKey)) {
                    $branchStore[$storeKey] = $cellValue;
                }
 
                // if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
            } elseif (preg_match('/^' . self::CALCULATION_REGEXP_FUNCTION . '$/miu', $token ?? '', $matches)) {
                if ($pCellParent) {
                    $pCell->attach($pCellParent);
                }
 
                $functionName = $matches[1];
                $argCount = $stack->pop();
                $argCount = $argCount['value'];
                if ($functionName != 'MKMATRIX') {
                    $this->debugLog->writeDebugLog('Evaluating Function ', self::localeFunc($functionName), '() with ', (($argCount == 0) ? 'no' : $argCount), ' argument', (($argCount == 1) ? '' : 's'));
                }
                if ((isset(self::$phpSpreadsheetFunctions[$functionName])) || (isset(self::$controlFunctions[$functionName]))) {    // function
                    $passByReference = false;
                    $passCellReference = false;
                    $functionCall = null;
                    if (isset(self::$phpSpreadsheetFunctions[$functionName])) {
                        $functionCall = self::$phpSpreadsheetFunctions[$functionName]['functionCall'];
                        $passByReference = isset(self::$phpSpreadsheetFunctions[$functionName]['passByReference']);
                        $passCellReference = isset(self::$phpSpreadsheetFunctions[$functionName]['passCellReference']);
                    } elseif (isset(self::$controlFunctions[$functionName])) {
                        $functionCall = self::$controlFunctions[$functionName]['functionCall'];
                        $passByReference = isset(self::$controlFunctions[$functionName]['passByReference']);
                        $passCellReference = isset(self::$controlFunctions[$functionName]['passCellReference']);
                    }
                    // get the arguments for this function
                    $args = $argArrayVals = [];
                    for ($i = 0; $i < $argCount; ++$i) {
                        $arg = $stack->pop();
                        $a = $argCount - $i - 1;
                        if (
                            ($passByReference) &&
                            (isset(self::$phpSpreadsheetFunctions[$functionName]['passByReference'][$a])) &&
                            (self::$phpSpreadsheetFunctions[$functionName]['passByReference'][$a])
                        ) {
                            if ($arg['reference'] === null) {
                                $args[] = $cellID;
                                if ($functionName != 'MKMATRIX') {
                                    $argArrayVals[] = $this->showValue($cellID);
                                }
                            } else {
                                $args[] = $arg['reference'];
                                if ($functionName != 'MKMATRIX') {
                                    $argArrayVals[] = $this->showValue($arg['reference']);
                                }
                            }
                        } else {
                            $args[] = self::unwrapResult($arg['value']);
                            if ($functionName != 'MKMATRIX') {
                                $argArrayVals[] = $this->showValue($arg['value']);
                            }
                        }
                    }
 
                    //    Reverse the order of the arguments
                    krsort($args);
 
                    if (($passByReference) && ($argCount == 0)) {
                        $args[] = $cellID;
                        $argArrayVals[] = $this->showValue($cellID);
                    }
 
                    if ($functionName != 'MKMATRIX') {
                        if ($this->debugLog->getWriteDebugLog()) {
                            krsort($argArrayVals);
                            $this->debugLog->writeDebugLog('Evaluating ', self::localeFunc($functionName), '( ', implode(self::$localeArgumentSeparator . ' ', Functions::flattenArray($argArrayVals)), ' )');
                        }
                    }
 
                    //    Process the argument with the appropriate function call
                    $args = $this->addCellReference($args, $passCellReference, $functionCall, $pCell);
 
                    if (!is_array($functionCall)) {
                        foreach ($args as &$arg) {
                            $arg = Functions::flattenSingleValue($arg);
                        }
                        unset($arg);
                    }
 
                    $result = call_user_func_array($functionCall, $args);
 
                    if ($functionName != 'MKMATRIX') {
                        $this->debugLog->writeDebugLog('Evaluation Result for ', self::localeFunc($functionName), '() function call is ', $this->showTypeDetails($result));
                    }
                    $stack->push('Value', self::wrapResult($result));
                    if (isset($storeKey)) {
                        $branchStore[$storeKey] = $result;
                    }
                }
            } else {
                // if the token is a number, boolean, string or an Excel error, push it onto the stack
                if (isset(self::$excelConstants[strtoupper($token ?? '')])) {
                    $excelConstant = strtoupper($token);
                    $stack->push('Constant Value', self::$excelConstants[$excelConstant]);
                    if (isset($storeKey)) {
                        $branchStore[$storeKey] = self::$excelConstants[$excelConstant];
                    }
                    $this->debugLog->writeDebugLog('Evaluating Constant ', $excelConstant, ' as ', $this->showTypeDetails(self::$excelConstants[$excelConstant]));
                } elseif ((is_numeric($token)) || ($token === null) || (is_bool($token)) || ($token == '') || ($token[0] == self::FORMULA_STRING_QUOTE) || ($token[0] == '#')) {
                    $stack->push('Value', $token);
                    if (isset($storeKey)) {
                        $branchStore[$storeKey] = $token;
                    }
                    // if the token is a named range or formula, evaluate it and push the result onto the stack
                } elseif (preg_match('/^' . self::CALCULATION_REGEXP_DEFINEDNAME . '$/miu', $token, $matches)) {
                    $definedName = $matches[6];
                    if ($pCell === null || $pCellWorksheet === null) {
                        return $this->raiseFormulaError("undefined name '$token'");
                    }
 
                    $this->debugLog->writeDebugLog('Evaluating Defined Name ', $definedName);
                    $namedRange = DefinedName::resolveName($definedName, $pCellWorksheet);
                    if ($namedRange === null) {
                        return $this->raiseFormulaError("undefined name '$definedName'");
                    }
 
                    $result = $this->evaluateDefinedName($pCell, $namedRange, $pCellWorksheet, $stack);
                    if (isset($storeKey)) {
                        $branchStore[$storeKey] = $result;
                    }
                } else {
                    return $this->raiseFormulaError("undefined name '$token'");
                }
            }
        }
        // when we're out of tokens, the stack should have a single element, the final result
        if ($stack->count() != 1) {
            return $this->raiseFormulaError('internal error');
        }
        $output = $stack->pop();
        $output = $output['value'];
 
        return $output;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ raiseFormulaError()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::raiseFormulaError ( $errorMessage )

protected

Definition at line 5219 of file Calculation.php.

    {
        $this->formulaError = $errorMessage;
        $this->cyclicReferenceStack->clear();
        if (!$this->suppressFormulaErrors) {
            throw new Exception($errorMessage);
        }
        trigger_error($errorMessage, E_USER_ERROR);
 
        return false;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\convertMatrixReferences(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack().

Here is the caller graph for this function:

◆ renameCalculationCacheForWorksheet()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::renameCalculationCacheForWorksheet	(	$fromWorksheetName,
		$toWorksheetName
	)

Rename calculation cache for a specified worksheet.

Parameters

string	$fromWorksheetName
string	$toWorksheetName

Definition at line 2944 of file Calculation.php.

                                                                                            : void
    {
        if (isset($this->calculationCache[$fromWorksheetName])) {
            $this->calculationCache[$toWorksheetName] = &$this->calculationCache[$fromWorksheetName];
            unset($this->calculationCache[$fromWorksheetName]);
        }
    }

◆ resizeMatricesExtend()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::resizeMatricesExtend	(	&	$matrix1,
		&	$matrix2,
			$matrix1Rows,
			$matrix1Columns,
			$matrix2Rows,
			$matrix2Columns
	)

staticprivate

Ensure that paired matrix operands are both matrices of the same size.

Parameters

mixed	$matrix1	First matrix operand
mixed	$matrix2	Second matrix operand
int	$matrix1Rows	Row size of first matrix operand
int	$matrix1Columns	Column size of first matrix operand
int	$matrix2Rows	Row size of second matrix operand
int	$matrix2Columns	Column size of second matrix operand

Definition at line 3674 of file Calculation.php.

                                                                                                                                    : void
    {
        if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
            if ($matrix2Columns < $matrix1Columns) {
                for ($i = 0; $i < $matrix2Rows; ++$i) {
                    $x = $matrix2[$i][$matrix2Columns - 1];
                    for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {
                        $matrix2[$i][$j] = $x;
                    }
                }
            }
            if ($matrix2Rows < $matrix1Rows) {
                $x = $matrix2[$matrix2Rows - 1];
                for ($i = 0; $i < $matrix1Rows; ++$i) {
                    $matrix2[$i] = $x;
                }
            }
        }
 
        if (($matrix1Columns < $matrix2Columns) || ($matrix1Rows < $matrix2Rows)) {
            if ($matrix1Columns < $matrix2Columns) {
                for ($i = 0; $i < $matrix1Rows; ++$i) {
                    $x = $matrix1[$i][$matrix1Columns - 1];
                    for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {
                        $matrix1[$i][$j] = $x;
                    }
                }
            }
            if ($matrix1Rows < $matrix2Rows) {
                $x = $matrix1[$matrix1Rows - 1];
                for ($i = 0; $i < $matrix2Rows; ++$i) {
                    $matrix1[$i] = $x;
                }
            }
        }
    }

References $i, and $x.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\checkMatrixOperands().

Here is the caller graph for this function:

◆ resizeMatricesShrink()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::resizeMatricesShrink	(	&	$matrix1,
		&	$matrix2,
			$matrix1Rows,
			$matrix1Columns,
			$matrix2Rows,
			$matrix2Columns
	)

staticprivate

Ensure that paired matrix operands are both matrices of the same size.

Parameters

mixed	$matrix1	First matrix operand
mixed	$matrix2	Second matrix operand
int	$matrix1Rows	Row size of first matrix operand
int	$matrix1Columns	Column size of first matrix operand
int	$matrix2Rows	Row size of second matrix operand
int	$matrix2Columns	Column size of second matrix operand

Definition at line 3631 of file Calculation.php.

                                                                                                                                    : void
    {
        if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
            if ($matrix2Rows < $matrix1Rows) {
                for ($i = $matrix2Rows; $i < $matrix1Rows; ++$i) {
                    unset($matrix1[$i]);
                }
            }
            if ($matrix2Columns < $matrix1Columns) {
                for ($i = 0; $i < $matrix1Rows; ++$i) {
                    for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {
                        unset($matrix1[$i][$j]);
                    }
                }
            }
        }
 
        if (($matrix1Columns < $matrix2Columns) || ($matrix1Rows < $matrix2Rows)) {
            if ($matrix1Rows < $matrix2Rows) {
                for ($i = $matrix1Rows; $i < $matrix2Rows; ++$i) {
                    unset($matrix2[$i]);
                }
            }
            if ($matrix1Columns < $matrix2Columns) {
                for ($i = 0; $i < $matrix2Rows; ++$i) {
                    for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {
                        unset($matrix2[$i][$j]);
                    }
                }
            }
        }
    }

References $i.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\checkMatrixOperands().

Here is the caller graph for this function:

◆ saveValueToCache()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::saveValueToCache	(	$cellReference,
		$cellValue
	)

Parameters

string	$cellReference
mixed	$cellValue

Definition at line 3466 of file Calculation.php.

                                                                : void
    {
        if ($this->calculationCacheEnabled) {
            $this->calculationCache[$cellReference] = $cellValue;
        }
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

Here is the caller graph for this function:

◆ setArrayReturnType()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::setArrayReturnType ( $returnType )

static

Set the Array Return Type (Array or Value of first element in the array).

Parameters

string $returnType Array return type

Returns: bool Success or failure

Definition at line 2856 of file Calculation.php.

    {
        if (
            ($returnType == self::RETURN_ARRAY_AS_VALUE) ||
            ($returnType == self::RETURN_ARRAY_AS_ERROR) ||
            ($returnType == self::RETURN_ARRAY_AS_ARRAY)
        ) {
            self::$returnArrayAsType = $returnType;
 
            return true;
        }
 
        return false;
    }

Referenced by PhpOffice\PhpSpreadsheet\Writer\Html\generateHtmlAll(), and PhpOffice\PhpSpreadsheet\Writer\Csv\save().

Here is the caller graph for this function:

◆ setBranchPruningEnabled()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::setBranchPruningEnabled ( $enabled )

Enable/disable calculation cache.

Parameters

mixed $enabled

Definition at line 2957 of file Calculation.php.

                                                     : void
    {
        $this->branchPruningEnabled = $enabled;
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\disableBranchPruning(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\enableBranchPruning().

Here is the caller graph for this function:

◆ setCalculationCacheEnabled()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::setCalculationCacheEnabled ( $pValue )

Enable/disable calculation cache.

Parameters

bool $pValue

Definition at line 2896 of file Calculation.php.

                                                       : void
    {
        $this->calculationCacheEnabled = $pValue;
        $this->clearCalculationCache();
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\clearCalculationCache().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\disableCalculationCache(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\enableCalculationCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setLocale()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::setLocale ( string $locale )

Set the locale code.

Parameters

string $locale The locale to use for formula translation, eg: 'en_us'

Returns: bool

Definition at line 3009 of file Calculation.php.

    {
        //    Identify our locale and language
        $language = $locale = strtolower($locale);
        if (strpos($locale, '_') !== false) {
            [$language] = explode('_', $locale);
        }
        if (count(self::$validLocaleLanguages) == 1) {
            self::loadLocales();
        }
 
        //    Test whether we have any language data for this language (any locale)
        if (in_array($language, self::$validLocaleLanguages)) {
            //    initialise language/locale settings
            self::$localeFunctions = [];
            self::$localeArgumentSeparator = ',';
            self::$localeBoolean = ['TRUE' => 'TRUE', 'FALSE' => 'FALSE', 'NULL' => 'NULL'];
 
            //    Default is US English, if user isn't requesting US english, then read the necessary data from the locale files
            if ($locale !== 'en_us') {
                $localeDir = implode(DIRECTORY_SEPARATOR, [__DIR__, 'locale', null]);
                //    Search for a file with a list of function names for locale
                try {
                    $functionNamesFile = $this->getLocaleFile($localeDir, $locale, $language, 'functions');
                } catch (Exception $e) {
                    return false;
                }
 
                //    Retrieve the list of locale or language specific function names
                $localeFunctions = file($functionNamesFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
                foreach ($localeFunctions as $localeFunction) {
                    [$localeFunction] = explode('##', $localeFunction); //    Strip out comments
                    if (strpos($localeFunction, '=') !== false) {
                        [$fName, $lfName] = array_map('trim', explode('=', $localeFunction));
                        if ((isset(self::$phpSpreadsheetFunctions[$fName])) && ($lfName != '') && ($fName != $lfName)) {
                            self::$localeFunctions[$fName] = $lfName;
                        }
                    }
                }
                //    Default the TRUE and FALSE constants to the locale names of the TRUE() and FALSE() functions
                if (isset(self::$localeFunctions['TRUE'])) {
                    self::$localeBoolean['TRUE'] = self::$localeFunctions['TRUE'];
                }
                if (isset(self::$localeFunctions['FALSE'])) {
                    self::$localeBoolean['FALSE'] = self::$localeFunctions['FALSE'];
                }
 
                try {
                    $configFile = $this->getLocaleFile($localeDir, $locale, $language, 'config');
                } catch (Exception $e) {
                    return false;
                }
 
                $localeSettings = file($configFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
                foreach ($localeSettings as $localeSetting) {
                    [$localeSetting] = explode('##', $localeSetting); //    Strip out comments
                    if (strpos($localeSetting, '=') !== false) {
                        [$settingName, $settingValue] = array_map('trim', explode('=', $localeSetting));
                        $settingName = strtoupper($settingName);
                        if ($settingValue !== '') {
                            switch ($settingName) {
                                case 'ARGUMENTSEPARATOR':
                                    self::$localeArgumentSeparator = $settingValue;
 
                                    break;
                            }
                        }
                    }
                }
            }
 
            self::$functionReplaceFromExcel = self::$functionReplaceToExcel =
            self::$functionReplaceFromLocale = self::$functionReplaceToLocale = null;
            self::$localeLanguage = $locale;
 
            return true;
        }
 
        return false;
    }

References $language, PhpOffice\PhpSpreadsheet\Calculation\Calculation\$localeFunctions, PhpOffice\PhpSpreadsheet\Calculation\Calculation\getLocaleFile(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\loadLocales().

Here is the call graph for this function:

◆ showTypeDetails()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::showTypeDetails ( $value )

private

Format type and details of an operand for display in the log (based on operand type).

Parameters

mixed $value First matrix operand

Returns: null|string

Definition at line 3756 of file Calculation.php.

    {
        if ($this->debugLog->getWriteDebugLog()) {
            $testArray = Functions::flattenArray($value);
            if (count($testArray) == 1) {
                $value = array_pop($testArray);
            }
 
            if ($value === null) {
                return 'a NULL value';
            } elseif (is_float($value)) {
                $typeString = 'a floating point number';
            } elseif (is_int($value)) {
                $typeString = 'an integer number';
            } elseif (is_bool($value)) {
                $typeString = 'a boolean';
            } elseif (is_array($value)) {
                $typeString = 'a matrix';
            } else {
                if ($value == '') {
                    return 'an empty string';
                } elseif ($value[0] == '#') {
                    return 'a ' . $value . ' error';
                }
                $typeString = 'a string';
            }
 
            return $typeString . ' with a value of ' . $this->showValue($value);
        }
 
        return null;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenArray(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showValue().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeArrayComparison(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeNumericBinaryOperation(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\validateBinaryOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ showValue()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::showValue ( $value )

private

Format details of an operand for display in the log (based on operand type).

Parameters

mixed $value First matrix operand

Returns: mixed

Definition at line 3718 of file Calculation.php.

    {
        if ($this->debugLog->getWriteDebugLog()) {
            $testArray = Functions::flattenArray($value);
            if (count($testArray) == 1) {
                $value = array_pop($testArray);
            }
 
            if (is_array($value)) {
                $returnMatrix = [];
                $pad = $rpad = ', ';
                foreach ($value as $row) {
                    if (is_array($row)) {
                        $returnMatrix[] = implode($pad, array_map([$this, 'showValue'], $row));
                        $rpad = '; ';
                    } else {
                        $returnMatrix[] = $this->showValue($row);
                    }
                }
 
                return '{ ' . implode($rpad, $returnMatrix) . ' }';
            } elseif (is_string($value) && (trim($value, self::FORMULA_STRING_QUOTE) == $value)) {
                return self::FORMULA_STRING_QUOTE . $value . self::FORMULA_STRING_QUOTE;
            } elseif (is_bool($value)) {
                return ($value) ? self::$localeBoolean['TRUE'] : self::$localeBoolean['FALSE'];
            }
        }
 
        return Functions::flattenSingleValue($value);
    }

References $row, PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenArray(), PhpOffice\PhpSpreadsheet\Calculation\Functions\flattenSingleValue(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\FORMULA_STRING_QUOTE, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showValue().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeArrayComparison(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\showValue().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ strcmpAllowNull()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::strcmpAllowNull	(	$str1,
		$str2
	)

private

PHP8.1 deprecates passing null to strcmp.

Parameters

null \| string	$str1	First string value for the comparison
null \| string	$str2	Second string value for the comparison

Returns: int

Definition at line 5120 of file Calculation.php.

    {
        return strcmp($str1 ?? '', $str2 ?? '');
    }

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

Here is the caller graph for this function:

◆ strcmpLowercaseFirst()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::strcmpLowercaseFirst	(	$str1,
		$str2
	)

private

Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters.

Parameters

null \| string	$str1	First string value for the comparison
null \| string	$str2	Second string value for the comparison

Returns: int

Definition at line 5104 of file Calculation.php.

    {
        $inversedStr1 = Shared\StringHelper::strCaseReverse($str1);
        $inversedStr2 = Shared\StringHelper::strCaseReverse($str2);
 
        return strcmp($inversedStr1 ?? '', $inversedStr2 ?? '');
    }

References PhpOffice\PhpSpreadsheet\Shared\StringHelper\strCaseReverse().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ translateFormula()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::translateFormula	(	array	$from,
		array	$to,
			$formula,
			$fromSeparator,
			$toSeparator
	)

staticprivate

Parameters

string[]	$from
string[]	$to
string	$formula
string	$fromSeparator
string	$toSeparator

Returns: string

Definition at line 3131 of file Calculation.php.

    {
        //    Convert any Excel function names to the required language
        if (self::$localeLanguage !== 'en_us') {
            $inBraces = false;
            //    If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
            if (strpos($formula, self::FORMULA_STRING_QUOTE) !== false) {
                //    So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
                //        the formula
                $temp = explode(self::FORMULA_STRING_QUOTE, $formula);
                $i = false;
                foreach ($temp as &$value) {
                    //    Only count/replace in alternating array entries
                    if ($i = !$i) {
                        $value = preg_replace($from, $to, $value);
                        $value = self::translateSeparator($fromSeparator, $toSeparator, $value, $inBraces);
                    }
                }
                unset($value);
                //    Then rebuild the formula string
                $formula = implode(self::FORMULA_STRING_QUOTE, $temp);
            } else {
                //    If there's no quoted strings, then we do a simple count/replace
                $formula = preg_replace($from, $to, $formula);
                $formula = self::translateSeparator($fromSeparator, $toSeparator, $formula, $inBraces);
            }
        }
 
        return $formula;
    }

References $from, $i, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\translateSeparator().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_translateFormulaToEnglish(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\_translateFormulaToLocale().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ translateSeparator()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::translateSeparator	(		$fromSeparator,
			$toSeparator,
			$formula,
		&	$inBraces
	)

static

Parameters

string	$fromSeparator
string	$toSeparator
string	$formula
bool	$inBraces

Returns: string

Definition at line 3098 of file Calculation.php.

    {
        $strlen = mb_strlen($formula);
        for ($i = 0; $i < $strlen; ++$i) {
            $chr = mb_substr($formula, $i, 1);
            switch ($chr) {
                case self::FORMULA_OPEN_FUNCTION_BRACE:
                    $inBraces = true;
 
                    break;
                case self::FORMULA_CLOSE_FUNCTION_BRACE:
                    $inBraces = false;
 
                    break;
                case $fromSeparator:
                    if (!$inBraces) {
                        $formula = mb_substr($formula, 0, $i) . $toSeparator . mb_substr($formula, $i + 1);
                    }
            }
        }
 
        return $formula;
    }

References $i, PhpOffice\PhpSpreadsheet\Calculation\Calculation\FORMULA_CLOSE_FUNCTION_BRACE, and PhpOffice\PhpSpreadsheet\Calculation\Calculation\FORMULA_OPEN_FUNCTION_BRACE.

Referenced by PhpOffice\PhpSpreadsheet\Reader\Ods\BaseReader\convertToExcelFormulaValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\translateFormula().

Here is the caller graph for this function:

◆ unwrapResult()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::unwrapResult ( $value )

static

Remove quotes used as a wrapper to identify string values.

Parameters

mixed $value

Returns: mixed

Definition at line 3269 of file Calculation.php.

    {
        if (is_string($value)) {
            if ((isset($value[0])) && ($value[0] == self::FORMULA_STRING_QUOTE) && (substr($value, -1) == self::FORMULA_STRING_QUOTE)) {
                return substr($value, 1, -1);
            }
            //    Convert numeric errors to NAN error
        } elseif ((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
            return Functions::NAN();
        }
 
        return $value;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Functions\NAN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validateBinaryOperand()

PhpOffice\PhpSpreadsheet\Calculation\Calculation::validateBinaryOperand	(	&	$operand,
		&	$stack
	)

private

Definition at line 4902 of file Calculation.php.

    {
        if (is_array($operand)) {
            if ((count($operand, COUNT_RECURSIVE) - count($operand)) == 1) {
                do {
                    $operand = array_pop($operand);
                } while (is_array($operand));
            }
        }
        //    Numbers, matrices and booleans can pass straight through, as they're already valid
        if (is_string($operand)) {
            //    We only need special validations for the operand if it is a string
            //    Start by stripping off the quotation marks we use to identify true excel string values internally
            if ($operand > '' && $operand[0] == self::FORMULA_STRING_QUOTE) {
                $operand = self::unwrapResult($operand);
            }
            //    If the string is a numeric value, we treat it as a numeric, so no further testing
            if (!is_numeric($operand)) {
                //    If not a numeric, test to see if the value is an Excel error, and so can't be used in normal binary operations
                if ($operand > '' && $operand[0] == '#') {
                    $stack->push('Value', $operand);
                    $this->debugLog->writeDebugLog('Evaluation Result is ', $this->showTypeDetails($operand));
 
                    return false;
                } elseif (!Shared\StringHelper::convertToNumberIfFraction($operand)) {
                    //    If not a numeric or a fraction, then it's a text string, and so can't be used in mathematical binary operations
                    $stack->push('Error', '#VALUE!');
                    $this->debugLog->writeDebugLog('Evaluation Result is a ', $this->showTypeDetails('#VALUE!'));
 
                    return false;
                }
            }
        }
 
        //    return a true if the value of the operand is one that we can use in normal binary operations
        return true;
    }

References PhpOffice\PhpSpreadsheet\Shared\StringHelper\convertToNumberIfFraction(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\showTypeDetails(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\unwrapResult().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeNumericBinaryOperation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wrapResult()

static PhpOffice\PhpSpreadsheet\Calculation\Calculation::wrapResult ( $value )

static

Wrap string values in quotes.

Parameters

mixed $value

Returns: mixed

Definition at line 3243 of file Calculation.php.

    {
        if (is_string($value)) {
            //    Error values cannot be "wrapped"
            if (preg_match('/^' . self::CALCULATION_REGEXP_ERROR . '$/i', $value, $match)) {
                //    Return Excel errors "as is"
                return $value;
            }
 
            //    Return strings wrapped in quotes
            return self::FORMULA_STRING_QUOTE . $value . self::FORMULA_STRING_QUOTE;
        } elseif ((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
            //    Convert numeric errors to NaN error
            return Functions::NAN();
        }
 
        return $value;
    }

References PhpOffice\PhpSpreadsheet\Calculation\Calculation\FORMULA_STRING_QUOTE, and PhpOffice\PhpSpreadsheet\Calculation\Functions\NAN().

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue(), PhpOffice\PhpSpreadsheet\Calculation\Functions\ifCondition(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\internalParseFormula(), and PhpOffice\PhpSpreadsheet\Calculation\Database\DatabaseAbstract\processCondition().

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

◆ $binaryOperators

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$binaryOperators

staticprivate

Initial value:

= [
        '+' => true, '-' => true, '*' => true, '/' => true,
        '^' => true, '&' => true, '>' => true, '<' => true,
        '=' => true, '>=' => true, '<=' => true, '<>' => true,
        '|' => true, ':' => true,
    ]

Definition at line 110 of file Calculation.php.

◆ $branchPruningEnabled

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$branchPruningEnabled = true

private

Definition at line 90 of file Calculation.php.

◆ $branchStoreKeyCounter

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$branchStoreKeyCounter = 0

private

Definition at line 88 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getUnusedBranchStoreKey().

◆ $calculationCache

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$calculationCache = []

private

Definition at line 74 of file Calculation.php.

◆ $calculationCacheEnabled

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$calculationCacheEnabled = true

private

Definition at line 81 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getCalculationCacheEnabled().

◆ $cellStack

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cellStack = []

private

Definition at line 154 of file Calculation.php.

◆ $comparisonOperators

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$comparisonOperators = ['>' => true, '<' => true, '=' => true, '>=' => true, '<=' => true, '<>' => true]

staticprivate

Definition at line 3859 of file Calculation.php.

◆ $controlFunctions

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$controlFunctions

staticprivate

Initial value:

= [
        'MKMATRIX' => [
            'argumentCount' => '*',
            'functionCall' => [Internal\MakeMatrix::class, 'make'],
        ],
        'NAME.ERROR' => [
            'argumentCount' => '*',
            'functionCall' => [Functions::class, 'NAME'],
        ],
        'WILDCARDMATCH' => [
            'argumentCount' => '2',
            'functionCall' => [Internal\WildcardMatch::class, 'compare'],
        ],
    ]

Definition at line 2743 of file Calculation.php.

◆ $cyclicFormulaCell

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicFormulaCell = ''

private

Definition at line 165 of file Calculation.php.

◆ $cyclicFormulaCount

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicFormulaCount = 1

Definition at line 172 of file Calculation.php.

◆ $cyclicFormulaCounter

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicFormulaCounter = 1

private

Definition at line 163 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_calculateFormulaValue().

◆ $cyclicReferenceStack

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$cyclicReferenceStack

private

Definition at line 152 of file Calculation.php.

◆ $debugLog

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$debugLog

private

Definition at line 122 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getDebugLog().

◆ $delta

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$delta = 0.1e-12

private

Definition at line 179 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions\Beta\betaFraction(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\executeBinaryComparisonOperation().

◆ $excelConstants

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$excelConstants

staticprivate

Initial value:

= [
        'TRUE' => true,
        'FALSE' => false,
        'NULL' => null,
    ]

Definition at line 224 of file Calculation.php.

◆ $formulaError

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$formulaError

Definition at line 138 of file Calculation.php.

◆ $functionReplaceFromExcel

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceFromExcel = null

staticprivate

Definition at line 3162 of file Calculation.php.

◆ $functionReplaceFromLocale

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceFromLocale = null

staticprivate

Definition at line 3191 of file Calculation.php.

◆ $functionReplaceToExcel

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceToExcel = null

staticprivate

Definition at line 3193 of file Calculation.php.

◆ $functionReplaceToLocale

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$functionReplaceToLocale = null

staticprivate

Definition at line 3164 of file Calculation.php.

◆ $instance

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$instance

staticprivate

Definition at line 60 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getInstance(), PhpOffice\PhpSpreadsheet\Calculation\TextData\SUBSTITUTE(), and PhpOffice\PhpSpreadsheet\Calculation\TextData\Replace\substitute().

◆ $localeArgumentSeparator

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeArgumentSeparator = ','

staticprivate

Definition at line 203 of file Calculation.php.

◆ $localeBoolean

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeBoolean

static

Initial value:

= [
        'TRUE' => 'TRUE',
        'FALSE' => 'FALSE',
        'NULL' => 'NULL',
    ]

Definition at line 212 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\_translateFormulaToLocale().

◆ $localeFunctions

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeFunctions = []

staticprivate

Definition at line 205 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\setLocale().

◆ $localeLanguage

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$localeLanguage = 'en_us'

staticprivate

Definition at line 186 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getLocale().

◆ $operatorAssociativity

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$operatorAssociativity

staticprivate

Initial value:

= [
        '^' => 0, 
        '*' => 0, '/' => 0, 
        '+' => 0, '-' => 0, 
        '&' => 0, 
        '|' => 0, ':' => 0, 
        '>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0, 
    ]

Definition at line 3848 of file Calculation.php.

◆ $operatorPrecedence

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$operatorPrecedence

staticprivate

Initial value:

= [
        ':' => 8, 
        '|' => 7, 
        '~' => 6, 
        '%' => 5, 
        '^' => 4, 
        '*' => 3, '/' => 3, 
        '+' => 2, '-' => 2, 
        '&' => 1, 
        '>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0, 
    ]

Definition at line 3864 of file Calculation.php.

◆ $operators

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$operators

staticprivate

Initial value:

= [
        '+' => true, '-' => true, '*' => true, '/' => true,
        '^' => true, '&' => true, '%' => false, '~' => false,
        '>' => true, '<' => true, '=' => true, '>=' => true,
        '<=' => true, '<>' => true, '|' => true, ':' => true,
    ]

Definition at line 98 of file Calculation.php.

◆ $phpSpreadsheetFunctions

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$phpSpreadsheetFunctions

staticprivate

Definition at line 231 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\getFunctions().

◆ $referenceHelper

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$referenceHelper

staticprivate

Definition at line 145 of file Calculation.php.

◆ $returnArrayAsType

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$returnArrayAsType = self::RETURN_ARRAY_AS_VALUE

staticprivate

Definition at line 53 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateCellValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\getArrayReturnType().

◆ $spreadsheet

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$spreadsheet

private

Definition at line 67 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\__construct(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\evaluateDefinedName(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\getInstance().

◆ $suppressFormulaErrors

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$suppressFormulaErrors = false

Definition at line 131 of file Calculation.php.

◆ $validLocaleLanguages

PhpOffice\PhpSpreadsheet\Calculation\Calculation::$validLocaleLanguages

staticprivate

Initial value:

= [
        'en', 
    ]

Definition at line 194 of file Calculation.php.

◆ CALCULATION_REGEXP_CELLREF

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_CELLREF = '((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?\b([a-z]{1,3})\$?(\d{1,7})(?![\w.])'

Definition at line 30 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Indirect\INDIRECT(), PhpOffice\PhpSpreadsheet\Calculation\Functions\isFormula(), PhpOffice\PhpSpreadsheet\Writer\Xls\Workbook\parseDefinedNameValue(), and PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Formula\text().

◆ CALCULATION_REGEXP_CELLREF_RELATIVE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_CELLREF_RELATIVE = '((([^\s\(,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?(\$?\b[a-z]{1,3})(\$?\d{1,7})(?![\w.])'

Definition at line 32 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Ods\NamedExpressions\convertAddress(), PhpOffice\PhpSpreadsheet\Writer\Ods\Formula\convertCellReferences(), and PhpOffice\PhpSpreadsheet\ReferenceHelper\updateCellReferencesAllWorksheets().

◆ CALCULATION_REGEXP_COLUMN_RANGE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_COLUMN_RANGE = '(((([^\s\(,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?(\$?[a-z]{1,3})):(?![.*])'

Definition at line 33 of file Calculation.php.

◆ CALCULATION_REGEXP_COLUMNRANGE_RELATIVE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_COLUMNRANGE_RELATIVE = '(\$?[a-z]{1,3}):(\$?[a-z]{1,3})'

Definition at line 37 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\ReferenceHelper\updateColumnRangesAllWorksheets().

◆ CALCULATION_REGEXP_DEFINEDNAME

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_DEFINEDNAME = '((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?([_\p{L}][_\p{L}\p{N}\.]*)'

Definition at line 40 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Xls\Parser\convert(), PhpOffice\PhpSpreadsheet\Writer\Ods\Formula\convertDefinedNames(), PhpOffice\PhpSpreadsheet\Writer\Xls\Parser\fact(), and PhpOffice\PhpSpreadsheet\Writer\Xls\Parser\match().

◆ CALCULATION_REGEXP_ERROR

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_ERROR = '\#[A-Z][A-Z0_\/]*[!\?]?'

Definition at line 42 of file Calculation.php.

◆ CALCULATION_REGEXP_FUNCTION

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_FUNCTION = '@?(?:_xlfn\.)?([\p{L}][\p{L}\p{N}\.]*)[\s]*\‍('

Definition at line 28 of file Calculation.php.

◆ CALCULATION_REGEXP_NUMBER

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_NUMBER = '[-+]?\d*\.?\d+(e[-+]?\d+)?'

Constants

Regular Expressions

Definition at line 22 of file Calculation.php.

◆ CALCULATION_REGEXP_OPENBRACE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_OPENBRACE = '\‍('

Definition at line 26 of file Calculation.php.

◆ CALCULATION_REGEXP_ROW_RANGE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_ROW_RANGE = '(((([^\s\(,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?(\$?[1-9][0-9]{0,6})):(?![.*])'

Definition at line 34 of file Calculation.php.

◆ CALCULATION_REGEXP_ROWRANGE_RELATIVE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_ROWRANGE_RELATIVE = '(\$?\d{1,7}):(\$?\d{1,7})'

Definition at line 38 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\ReferenceHelper\updateRowRangesAllWorksheets().

◆ CALCULATION_REGEXP_STRING

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::CALCULATION_REGEXP_STRING = '"(?:[^"]|"")*"'

Definition at line 24 of file Calculation.php.

◆ FORMULA_CLOSE_FUNCTION_BRACE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::FORMULA_CLOSE_FUNCTION_BRACE = '}'

Definition at line 50 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\convertMatrixReferences(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\translateSeparator().

◆ FORMULA_OPEN_FUNCTION_BRACE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::FORMULA_OPEN_FUNCTION_BRACE = '{'

Definition at line 49 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\convertMatrixReferences(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\translateSeparator().

◆ FORMULA_STRING_QUOTE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::FORMULA_STRING_QUOTE = '"'

Definition at line 51 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\processTokenStack(), PhpOffice\PhpSpreadsheet\Calculation\Calculation\showValue(), and PhpOffice\PhpSpreadsheet\Calculation\Calculation\wrapResult().

◆ RETURN_ARRAY_AS_ARRAY

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::RETURN_ARRAY_AS_ARRAY = 'array'

Definition at line 47 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Calculation\Calculation\calculateCellValue().

◆ RETURN_ARRAY_AS_ERROR

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::RETURN_ARRAY_AS_ERROR = 'error'

constants

Definition at line 45 of file Calculation.php.

◆ RETURN_ARRAY_AS_VALUE

const PhpOffice\PhpSpreadsheet\Calculation\Calculation::RETURN_ARRAY_AS_VALUE = 'value'

Definition at line 46 of file Calculation.php.

Referenced by PhpOffice\PhpSpreadsheet\Writer\Html\generateHtmlAll(), and PhpOffice\PhpSpreadsheet\Writer\Csv\save().

The documentation for this class was generated from the following file:

libs/composer/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Calculation.php

Public Member Functions

Static Public Member Functions

Data Fields

Static Public Attributes

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ __clone()

◆ _calculateFormulaValue()

◆ _translateFormulaToEnglish()

◆ _translateFormulaToLocale()

◆ addCellReference()

◆ calculate()

◆ calculateCellValue()

◆ calculateFormula()

◆ checkMatrixOperands()

◆ clearBranchStore()

◆ clearCalculationCache()

◆ clearCalculationCacheForWorksheet()

◆ convertMatrixReferences()

◆ dataTestReference()

◆ disableBranchPruning()

◆ disableCalculationCache()

◆ enableBranchPruning()

◆ enableCalculationCache()

◆ evaluateDefinedName()

◆ executeArrayComparison()

◆ executeBinaryComparisonOperation()

◆ executeNumericBinaryOperation()

◆ extractCellRange()

◆ extractNamedRange()

◆ flushInstance()

◆ getArrayReturnType()

◆ getCalculationCacheEnabled()

◆ getDebugLog()

◆ getFALSE()

◆ getFunctions()

◆ getImplementedFunctionNames()

◆ getInstance()

◆ getLocale()

◆ getLocaleFile()

◆ getMatrixDimensions()

◆ getTokensAsString()

◆ getTRUE()

◆ getUnusedBranchStoreKey()

◆ getValueFromCache()

◆ internalParseFormula()

◆ isImplemented()

◆ loadLocales()

◆ localeFunc()

◆ parseFormula()

◆ processTokenStack()

◆ raiseFormulaError()

◆ renameCalculationCacheForWorksheet()

◆ resizeMatricesExtend()

◆ resizeMatricesShrink()

◆ saveValueToCache()

◆ setArrayReturnType()

◆ setBranchPruningEnabled()

◆ setCalculationCacheEnabled()

◆ setLocale()

◆ showTypeDetails()

◆ showValue()

◆ strcmpAllowNull()

◆ strcmpLowercaseFirst()

◆ translateFormula()

◆ translateSeparator()

◆ unwrapResult()

◆ validateBinaryOperand()

◆ wrapResult()

Field Documentation

◆ $binaryOperators

◆ $branchPruningEnabled

◆ $branchStoreKeyCounter