PHPExcel_Calculation Class Reference

Collaboration diagram for PHPExcel_Calculation:

Public Member Functions
	__destruct ()
	flushInstance ()
	Flush the calculation cache for any existing instance of this class but only if a PHPExcel_Calculation instance exists. More...
	getDebugLog ()
	Get the debuglog for this claculation engine instance. More...
	__clone ()
	__clone implementation. More...
	getCalculationCacheEnabled ()
	Is calculation caching enabled? More...
	setCalculationCacheEnabled ($pValue=TRUE)
	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...
	getLocale ()
	Get the currently defined locale code. More...
	setLocale ($locale='en_us')
	Set the locale code. More...
	_translateFormulaToLocale ($formula)
	_translateFormulaToEnglish ($formula)
	calculate (PHPExcel_Cell $pCell=NULL)
	Calculate cell value (using formula from a cell ID) Retained for backward compatibility. More...
	calculateCellValue (PHPExcel_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, PHPExcel_Cell $pCell=NULL)
	Calculate the value of a formula. More...
	getValueFromCache ($cellReference, &$cellValue)
	saveValueToCache ($cellReference, $cellValue)
	_calculateFormulaValue ($formula, $cellID=null, PHPExcel_Cell $pCell=null)
	Parse a cell formula and calculate its value. More...
	extractCellRange (&$pRange='A1', PHPExcel_Worksheet $pSheet=NULL, $resetLog=TRUE)
	Extract range values. More...
	extractNamedRange (&$pRange='A1', PHPExcel_Worksheet $pSheet=NULL, $resetLog=TRUE)
	Extract range values. More...
	isImplemented ($pFunction='')
	Is a specific function implemented? More...
	listFunctions ()
	Get a list of all implemented functions as an array of function objects. More...
	listAllFunctionNames ()
	Get a list of all Excel function names. More...
	listFunctionNames ()
	Get a list of implemented Excel function names. More...

Static Public Member Functions
static	getInstance (PHPExcel $workbook=NULL)
	Get an instance of this class. More...
static	unsetInstance (PHPExcel $workbook=NULL)
	Unset 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 (&$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 = '@?([A-Z][A-Z0-9\.]*)[\s]*\('
const	CALCULATION_REGEXP_CELLREF = CALCULATION_REGEXP_CELLREF
const	CALCULATION_REGEXP_NAMEDRANGE = CALCULATION_REGEXP_NAMEDRANGE
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'
	$suppressFormulaErrors = FALSE
	$formulaError = NULL
	$cyclicFormulaCount = 1

Static Public Attributes
static	$_localeBoolean

Protected Member Functions
	_raiseFormulaError ($errorMessage)

Private Member Functions
	__construct (PHPExcel $workbook=NULL)
	_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)
	_parseFormula ($formula, PHPExcel_Cell $pCell=NULL)
	_processTokenStack ($tokens, $cellID=NULL, PHPExcel_Cell $pCell=NULL)
	_validateBinaryOperand ($cellID, &$operand, &$stack)
	_executeBinaryComparisonOperation ($cellID, $operand1, $operand2, $operation, &$stack, $recursingArrays=FALSE)
	strcmpLowercaseFirst ($str1, $str2)
	Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters. More...
	_executeNumericBinaryOperation ($cellID, $operand1, $operand2, $operation, $matrixFunction, &$stack)

Static Private Member Functions
static	_loadLocales ()
static	_translateFormula ($from, $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	_mkMatrix ()
static	_dataTestReference (&$operandData)

Private Attributes
	$_workbook
	$_calculationCache = array ()
	$_calculationCacheEnabled = TRUE
	$debugLog
	$_cyclicReferenceStack
	$_cellStack = array()
	$_cyclicFormulaCount = 1
	$_cyclicFormulaCell = ''
	$_savedPrecision = 14

Static Private Attributes
static	$returnArrayAsType = self::RETURN_ARRAY_AS_VALUE
static	$_instance
static	$_workbookSets
static	$_operators
static	$_binaryOperators
static	$_localeLanguage = 'en_us'
static	$_validLocaleLanguages
static	$_localeArgumentSeparator = ','
static	$_localeFunctions = array()
static	$_ExcelConstants
static	$_PHPExcelFunctions
static	$_controlFunctions
static	$functionReplaceFromExcel = NULL
static	$functionReplaceToLocale = NULL
static	$functionReplaceFromLocale = NULL
static	$functionReplaceToExcel = NULL
static	$_operatorAssociativity
static	$_comparisonOperators = array('>' => TRUE, '<' => TRUE, '=' => TRUE, '>=' => TRUE, '<=' => TRUE, '<>' => TRUE)
static	$_operatorPrecedence

Detailed Description

Definition at line 62 of file Calculation.php.

Constructor & Destructor Documentation

__construct()

PHPExcel_Calculation::__construct ( PHPExcel  $workbook = NULL )

private

Definition at line 1723 of file Calculation.php.

                                                                {
                $setPrecision = (PHP_INT_SIZE == 4) ? 14 : 16;
                $this->_savedPrecision = ini_get('precision');
                if ($this->_savedPrecision < $setPrecision) {
                        ini_set('precision',$setPrecision);
                }
                $this->delta = 1 * pow(10, -$setPrecision);

                if ($workbook !== NULL) {
                        self::$_workbookSets[$workbook->getID()] = $this;
                }

                $this->_workbook = $workbook;
                $this->_cyclicReferenceStack = new PHPExcel_CalcEngine_CyclicReferenceStack();
            $this->_debugLog = new PHPExcel_CalcEngine_Logger($this->_cyclicReferenceStack);
        }       //      function __construct()

__destruct()

PHPExcel_Calculation::__destruct

(

)

Definition at line 1741 of file Calculation.php.

                                     {
                if ($this->_savedPrecision != ini_get('precision')) {
                        ini_set('precision',$this->_savedPrecision);
                }
        }

Member Function Documentation

__clone()

PHPExcel_Calculation::__clone ( )

final

__clone implementation.

Cloning should not be allowed in a Singleton!

public

Exceptions

PHPExcel_Calculation_Exception

Definition at line 1822 of file Calculation.php.

                                        {
                throw new PHPExcel_Calculation_Exception ('Cloning the calculation engine is not allowed!');
        }       //      function __clone()

_calculateFormulaValue()

PHPExcel_Calculation::_calculateFormulaValue	(		$formula,
			$cellID = null,
		PHPExcel_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
PHPExcel_Cell	$pCell	Cell to calculate

Returns

mixed

Exceptions

PHPExcel_Calculation_Exception

Definition at line 2375 of file Calculation.php.

References $_cyclicFormulaCount, _parseFormula(), _processTokenStack(), _raiseFormulaError(), getValueFromCache(), and saveValueToCache().

Referenced by calculateCellValue(), and calculateFormula().

                                                                                                    {
                $cellValue = null;

                //      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;
                }

                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->_cyclicFormulaCount;
                                if ($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) {
                    $this->_cyclicFormulaCell = '';
                                        return $cellValue;
                                }
                        } elseif ($this->_cyclicFormulaCell == '') {
                                if ($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) {
                                        return $cellValue;
                                }
                                $this->_cyclicFormulaCell = $wsCellReference;
                        }
                }

                //      Parse the formula onto the token stack and calculate the value
                $this->_cyclicReferenceStack->push($wsCellReference);
                $cellValue = $this->_processTokenStack($this->_parseFormula($formula, $pCell), $cellID, $pCell);
                $this->_cyclicReferenceStack->pop();

                // Save to calculation cache
                if ($cellID !== NULL) {
                        $this->saveValueToCache($wsCellReference, $cellValue);
                }

                //      Return the calculated value
                return $cellValue;
        }       //      function _calculateFormulaValue()

Here is the call graph for this function:

Here is the caller graph for this function:

_checkMatrixOperands()

static PHPExcel_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
integer	$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

Definition at line 2438 of file Calculation.php.

References array.

                                                                                        {
                //      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)) {
                        list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand2);
                        $operand1 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand1));
                        $resize = 0;
                } elseif (!is_array($operand2)) {
                        list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand1);
                        $operand2 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand2));
                        $resize = 0;
                }

                list($matrix1Rows,$matrix1Columns) = self::_getMatrixDimensions($operand1);
                list($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 array( $matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
        }       //      function _checkMatrixOperands()

_convertMatrixReferences()

PHPExcel_Calculation::_convertMatrixReferences (   $formula )

private

Definition at line 2652 of file Calculation.php.

References _raiseFormulaError(), and array.

Referenced by _parseFormula().

                                                            {
                static $matrixReplaceFrom = array('{',';','}');
                static $matrixReplaceTo = array('MKMATRIX(MKMATRIX(','),MKMATRIX(','))');

                //      Convert any Excel matrix references to the MKMATRIX() function
                if (strpos($formula,'{') !== FALSE) {
                        //      If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
                        if (strpos($formula,'"') !== 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('"',$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,'{');
                                                $closeCount += substr_count($value,'}');
                                                $value = str_replace($matrixReplaceFrom,$matrixReplaceTo,$value);
                                        }
                                }
                                unset($value);
                                //      Then rebuild the formula string
                                $formula = implode('"',$temp);
                        } else {
                                //      If there's no quoted strings, then we do a simple count/replace
                                $openCount = substr_count($formula,'{');
                                $closeCount = substr_count($formula,'}');
                                $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 '}'");
                                } else {
                                        return $this->_raiseFormulaError("Formula Error: Unexpected '}' encountered");
                                }
                        } elseif ($openCount > $closeCount) {
                                if ($closeCount > 0) {
                                        return $this->_raiseFormulaError("Formula Error: Mismatched matrix braces '{'");
                                } else {
                                        return $this->_raiseFormulaError("Formula Error: Unexpected '{' encountered");
                                }
                        }
                }

                return $formula;
        }       //      function _convertMatrixReferences()

Here is the call graph for this function:

Here is the caller graph for this function:

_dataTestReference()

static PHPExcel_Calculation::_dataTestReference ( &  $operandData )

staticprivate

Definition at line 3082 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;
        }

_executeBinaryComparisonOperation()

PHPExcel_Calculation::_executeBinaryComparisonOperation (   $cellID,   $operand1,   $operand2,   $operation, &  $stack,   $recursingArrays = FALSE  )

private

Definition at line 3532 of file Calculation.php.

References $r, $result, $x, _showTypeDetails(), _showValue(), array, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\getCompatibilityMode(), and strcmpLowercaseFirst().

Referenced by _processTokenStack().

                                                                                                                                       {
                //      If we're dealing with matrix operations, we want a matrix result
                if ((is_array($operand1)) || (is_array($operand2))) {
                        $result = array();
                        if ((is_array($operand1)) && (!is_array($operand2))) {
                                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)) && (is_array($operand2))) {
                                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 {
                                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 TRUE;
                }

                //      Simple validate the two operands if they are string values
                if (is_string($operand1) && $operand1 > '' && $operand1{0} == '"') { $operand1 = self::_unwrapResult($operand1); }
                if (is_string($operand2) && $operand2 > '' && $operand2{0} == '"') { $operand2 = self::_unwrapResult($operand2); }

                // Use case insensitive comparaison if not OpenOffice mode
                if (PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE)
                {
                        if (is_string($operand1)) {
                                $operand1 = strtoupper($operand1);
                        }

                        if (is_string($operand2)) {
                                $operand2 = strtoupper($operand2);
                        }
                }

                $useLowercaseFirstComparison = is_string($operand1) && is_string($operand2) && PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_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 = strcmp($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 = strcmp($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 = strcmp($operand1, $operand2) <= 0;
                                }
                                break;
                        //      Inequality
                        case '<>':
                if (is_numeric($operand1) && is_numeric($operand2)) {
                    $result = (abs($operand1 - $operand2) > 1E-14);
                } else {
                    $result = strcmp($operand1, $operand2) != 0;
                }
                                break;
                }

                //      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 true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

_executeNumericBinaryOperation()

PHPExcel_Calculation::_executeNumericBinaryOperation (   $cellID,   $operand1,   $operand2,   $operation,   $matrixFunction, &  $stack  )

private

Definition at line 3661 of file Calculation.php.

References $result, _showTypeDetails(), _validateBinaryOperand(), PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\getCompatibilityMode(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by _processTokenStack().

                                                                                                                        {
                //      Validate the two operands
                if (!$this->_validateBinaryOperand($cellID,$operand1,$stack)) return FALSE;
                if (!$this->_validateBinaryOperand($cellID,$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 PHPExcel_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 (PHPExcel_Exception $ex) {
                                $this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                                $result = '#VALUE!';
                        }
                } else {
                        if ((PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) &&
                                ((is_string($operand1) && !is_numeric($operand1) && strlen($operand1)>0) || 
                 (is_string($operand2) && !is_numeric($operand2) && strlen($operand2)>0))) {
                                $result = PHPExcel_Calculation_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('Value','#DIV/0!');
                                                        $this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails('#DIV/0!'));
                                                        return FALSE;
                                                } else {
                                                        $result = $operand1 / $operand2;
                                                }
                                                break;
                                        //      Power
                                        case '^':
                                                $result = pow($operand1, $operand2);
                                                break;
                                }
                        }
                }

                //      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 TRUE;
        }       //      function _executeNumericBinaryOperation()

Here is the call graph for this function:

Here is the caller graph for this function:

_getMatrixDimensions()

static PHPExcel_Calculation::_getMatrixDimensions ( &  $matrix )

static

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

Parameters

mixed

&$matrix

matrix operand

Returns

array An array comprising the number of rows, and number of columns

Definition at line 2474 of file Calculation.php.

References array.

Referenced by PHPExcel_Calculation_LookupRef\COLUMNS(), and PHPExcel_Calculation_LookupRef\ROWS().

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

Here is the caller graph for this function:

_loadLocales()

static PHPExcel_Calculation::_loadLocales ( )

staticprivate

Definition at line 1747 of file Calculation.php.

References $filename.

                                               {
                $localeFileDirectory = PHPEXCEL_ROOT.'PHPExcel/locale/';
                foreach (glob($localeFileDirectory.'/*',GLOB_ONLYDIR) as $filename) {
                        $filename = substr($filename,strlen($localeFileDirectory)+1);
                        if ($filename != 'en') {
                                self::$_validLocaleLanguages[] = $filename;
                        }
                }
        }

_localeFunc()

static PHPExcel_Calculation::_localeFunc (   $function )

static

Definition at line 2142 of file Calculation.php.

Referenced by PHPExcel_Calculation_Token_Stack\push().

                                                      {
                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;
        }

Here is the caller graph for this function:

_mkMatrix()

static PHPExcel_Calculation::_mkMatrix ( )

staticprivate

Definition at line 2703 of file Calculation.php.

                                            {
                return func_get_args();
        }       //      function _mkMatrix()

_parseFormula()

PHPExcel_Calculation::_parseFormula (   $formula, PHPExcel_Cell  $pCell = NULL  )

private

Definition at line 2740 of file Calculation.php.

References $d, $output, _convertMatrixReferences(), _raiseFormulaError(), and array.

Referenced by _calculateFormulaValue(), and parseFormula().

                                                                              {
                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_NUMBER.
                                                           '|'.self::CALCULATION_REGEXP_STRING.
                                                           '|'.self::CALCULATION_REGEXP_OPENBRACE.
                                                           '|'.self::CALCULATION_REGEXP_NAMEDRANGE.
                                                           '|'.self::CALCULATION_REGEXP_ERROR.
                                                         ')/si';

                //      Start with initialisation
                $index = 0;
                $stack = new PHPExcel_Calculation_Token_Stack;
                $output = array();
                $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
                //      The guts of the lexical parser
                //      Loop through the formula extracting each operator and operand in turn
                while(TRUE) {
//echo 'Assessing Expression '.substr($formula, $index),PHP_EOL;
                        $opCharacter = $formula{$index};        //      Get the first character of the value at the current index position
//echo 'Initial character of expression block is '.$opCharacter,PHP_EOL;
                        if ((isset(self::$_comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset(self::$_comparisonOperators[$formula{$index+1}]))) {
                                $opCharacter .= $formula{++$index};
//echo 'Initial character of expression block is comparison operator '.$opCharacter.PHP_EOL;
                        }

                        //      Find out if we're currently at the beginning of a number, variable, cell reference, function, parenthesis or operand
                        $isOperandOrFunction = preg_match($regexpMatchString, substr($formula, $index), $match);
//echo '$isOperandOrFunction is '.(($isOperandOrFunction) ? 'True' : 'False').PHP_EOL;
//var_dump($match);

                        if ($opCharacter == '-' && !$expectingOperator) {                               //      Is it a negation instead of a minus?
//echo 'Element is a Negation operator',PHP_EOL;
                                $stack->push('Unary Operator','~');                                                     //      Put a negation on the stack
                                ++$index;                                                                                                       //              and drop the negation symbol
                        } elseif ($opCharacter == '%' && $expectingOperator) {
//echo 'Element is a Percentage operator',PHP_EOL;
                                $stack->push('Unary Operator','%');                                                     //      Put a percentage on the stack
                                ++$index;
                        } elseif ($opCharacter == '+' && !$expectingOperator) {                 //      Positive (unary plus rather than binary operator plus) can be discarded?
//echo 'Element is a Positive number, not Plus operator',PHP_EOL;
                                ++$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]) or $isOperandOrFunction) && $expectingOperator) {     //      Are we putting an operator on the stack?
//echo 'Element with value '.$opCharacter.' is an Operator',PHP_EOL;
                                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',$opCharacter);   //      Finally put our current operator onto the stack
                                ++$index;
                                $expectingOperator = FALSE;

                        } elseif ($opCharacter == ')' && $expectingOperator) {                  //      Are we expecting to close a parenthesis?
//echo 'Element is a Closing bracket',PHP_EOL;
                                $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 ")"');
                                        else $output[] = $o2;
                                }
                                $d = $stack->last(2);
                                if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches)) {  //      Did this parenthesis just close a function?
                                        $functionName = $matches[1];                                                                            //      Get the function name
//echo 'Closed Function is '.$functionName,PHP_EOL;
                                        $d = $stack->pop();
                                        $argumentCount = $d['value'];           //      See how many arguments there were (argument count is the next value stored on the stack)
//if ($argumentCount == 0) {
//      echo 'With no arguments',PHP_EOL;
//} elseif ($argumentCount == 1) {
//      echo 'With 1 argument',PHP_EOL;
//} else {
//      echo 'With '.$argumentCount.' arguments',PHP_EOL;
//}
                                        $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])) {
//echo 'Built-in function '.$functionName,PHP_EOL;
                                                $expectedArgumentCount = self::$_controlFunctions[$functionName]['argumentCount'];
                                                $functionCall = self::$_controlFunctions[$functionName]['functionCall'];
                                        } elseif (isset(self::$_PHPExcelFunctions[$functionName])) {
//echo 'PHPExcel function '.$functionName,PHP_EOL;
                                                $expectedArgumentCount = self::$_PHPExcelFunctions[$functionName]['argumentCount'];
                                                $functionCall = self::$_PHPExcelFunctions[$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;
                                        if (is_numeric($expectedArgumentCount)) {
                                                if ($expectedArgumentCount < 0) {
//echo '$expectedArgumentCount is between 0 and '.abs($expectedArgumentCount),PHP_EOL;
                                                        if ($argumentCount > abs($expectedArgumentCount)) {
                                                                $argumentCountError = TRUE;
                                                                $expectedArgumentCountString = 'no more than '.abs($expectedArgumentCount);
                                                        }
                                                } else {
//echo '$expectedArgumentCount is numeric '.$expectedArgumentCount,PHP_EOL;
                                                        if ($argumentCount != $expectedArgumentCount) {
                                                                $argumentCountError = TRUE;
                                                                $expectedArgumentCountString = $expectedArgumentCount;
                                                        }
                                                }
                                        } elseif ($expectedArgumentCount != '*') {
                                                $isOperandOrFunction = preg_match('/(\d*)([-+,])(\d*)/',$expectedArgumentCount,$argMatch);
//print_r($argMatch);
//echo PHP_EOL;
                                                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?
//echo 'Element is a Function argument separator',PHP_EOL;
                                while (($o2 = $stack->pop()) && $o2['value'] != '(') {          //      Pop off the stack back to the last (
                                        if ($o2 === NULL) return $this->_raiseFormulaError("Formula Error: Unexpected ,");
                                        else $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[] = array('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.'$/i', $d['value'], $matches))
                                        return $this->_raiseFormulaError("Formula Error: Unexpected ,");
                                $d = $stack->pop();
                                $stack->push($d['type'],++$d['value'],$d['reference']); // increment the argument count
                                $stack->push('Brace', '(');     // put the ( back on, we'll need to pop back to it again
                                $expectingOperator = FALSE;
                                $expectingOperand = TRUE;
                                ++$index;

                        } elseif ($opCharacter == '(' && !$expectingOperator) {
//                              echo 'Element is an Opening Bracket<br />';
                                $stack->push('Brace', '(');
                                ++$index;

                        } elseif ($isOperandOrFunction && !$expectingOperator) {        // do we now have a function/variable/number?
                                $expectingOperator = TRUE;
                                $expectingOperand = FALSE;
                                $val = $match[1];
                                $length = strlen($val);
//                              echo 'Element with value '.$val.' is an Operand, Variable, Constant, String, Number, Cell Reference or Function<br />';

                                if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $val, $matches)) {
                                        $val = preg_replace('/\s/u','',$val);
//                                      echo 'Element '.$val.' is a Function<br />';
                                        if (isset(self::$_PHPExcelFunctions[strtoupper($matches[1])]) || isset(self::$_controlFunctions[strtoupper($matches[1])])) {    // it's a function
                                                $stack->push('Function', strtoupper($val));
                                                $ax = preg_match('/^\s*(\s*\))/ui', substr($formula, $index+$length), $amatch);
                                                if ($ax) {
                                                        $stack->push('Operand Count for Function '.strtoupper($val).')', 0);
                                                        $expectingOperator = TRUE;
                                                } else {
                                                        $stack->push('Operand Count for Function '.strtoupper($val).')', 1);
                                                        $expectingOperator = FALSE;
                                                }
                                                $stack->push('Brace', '(');
                                        } else {        // it's a var w/ implicit multiplication
                                                $output[] = array('type' => 'Value', 'value' => $matches[1], 'reference' => NULL);
                                        }
                                } elseif (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $val, $matches)) {
//                                      echo 'Element '.$val.' is a Cell reference<br />';
                                        //      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['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
                                                        $startCellRef = $output[count($output)-1]['value'];
                                                        preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $startCellRef, $startMatches);
                                                        if ($startMatches[2] > '') {
                                                                $val = $startMatches[2].'!'.$val;
                                                        }
                                                } else {
                                                        return $this->_raiseFormulaError("3D Range references are not yet supported");
                                                }
                                        }

                                        $output[] = array('type' => 'Cell Reference', 'value' => $val, 'reference' => $val);
//                                      $expectingOperator = FALSE;
                                } else {        // it's a variable, constant, string, number or boolean
//                                      echo 'Element is a Variable, Constant, String, Number or Boolean<br />';
                                        //      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['value'] == ':') {
                                                $startRowColRef = $output[count($output)-1]['value'];
                                                $rangeWS1 = '';
                                                if (strpos('!',$startRowColRef) !== FALSE) {
                                                        list($rangeWS1,$startRowColRef) = explode('!',$startRowColRef);
                                                }
                                                if ($rangeWS1 != '') $rangeWS1 .= '!';
                                                $rangeWS2 = $rangeWS1;
                                                if (strpos('!',$val) !== FALSE) {
                                                        list($rangeWS2,$val) = explode('!',$val);
                                                }
                                                if ($rangeWS2 != '') $rangeWS2 .= '!';
                                                if ((is_integer($startRowColRef)) && (ctype_digit($val)) &&
                                                        ($startRowColRef <= 1048576) && ($val <= 1048576)) {
                                                        //      Row range
                                                        $endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestColumn() : 'XFD';     //      Max 16,384 columns for Excel2007
                                                        $output[count($output)-1]['value'] = $rangeWS1.'A'.$startRowColRef;
                                                        $val = $rangeWS2.$endRowColRef.$val;
                                                } elseif ((ctype_alpha($startRowColRef)) && (ctype_alpha($val)) &&
                                                        (strlen($startRowColRef) <= 3) && (strlen($val) <= 3)) {
                                                        //      Column range
                                                        $endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestRow() : 1048576;              //      Max 1,048,576 rows for Excel2007
                                                        $output[count($output)-1]['value'] = $rangeWS1.strtoupper($startRowColRef).'1';
                                                        $val = $rangeWS2.$val.$endRowColRef;
                                                }
                                        }

                                        $localeConstant = FALSE;
                                        if ($opCharacter == '"') {
//                                              echo 'Element is a String<br />';
                                                //      UnEscape any quotes within the string
                                                $val = self::_wrapResult(str_replace('""','"',self::_unwrapResult($val)));
                                        } elseif (is_numeric($val)) {
//                                              echo 'Element is a Number<br />';
                                                if ((strpos($val,'.') !== FALSE) || (stripos($val,'e') !== FALSE) || ($val > PHP_INT_MAX) || ($val < -PHP_INT_MAX)) {
//                                                      echo 'Casting '.$val.' to float<br />';
                                                        $val = (float) $val;
                                                } else {
//                                                      echo 'Casting '.$val.' to integer<br />';
                                                        $val = (integer) $val;
                                                }
                                        } elseif (isset(self::$_ExcelConstants[trim(strtoupper($val))])) {
                                                $excelConstant = trim(strtoupper($val));
//                                              echo 'Element '.$excelConstant.' is an Excel Constant<br />';
                                                $val = self::$_ExcelConstants[$excelConstant];
                                        } elseif (($localeConstant = array_search(trim(strtoupper($val)), self::$_localeBoolean)) !== FALSE) {
//                                              echo 'Element '.$localeConstant.' is an Excel Constant<br />';
                                                $val = self::$_ExcelConstants[$localeConstant];
                                        }
                                        $details = array('type' => 'Value', 'value' => $val, 'reference' => NULL);
                                        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[] = array('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 occured");
                        }
                        //      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");
                                } else {
                                        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
//                              echo 'Possible Intersect Operator<br />';
                                if (($expectingOperator) && (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'.*/Ui', substr($formula, $index), $match)) &&
                                        ($output[count($output)-1]['type'] == 'Cell Reference')) {
//                                      echo 'Element is an Intersect Operator<br />';
                                        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;
        }       //      function _parseFormula()

Here is the call graph for this function:

Here is the caller graph for this function:

_processTokenStack()

PHPExcel_Calculation::_processTokenStack (   $tokens,   $cellID = NULL, PHPExcel_Cell  $pCell = NULL  )

private

Definition at line 3098 of file Calculation.php.

References $data, $output, $result, $row, _executeBinaryComparisonOperation(), _executeNumericBinaryOperation(), _raiseFormulaError(), _showTypeDetails(), _showValue(), array, PHPExcel_Cell\columnIndexFromString(), PHPExcel_Cell\coordinateFromString(), extractCellRange(), extractNamedRange(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\REF(), and PHPExcel_Cell\stringFromColumnIndex().

Referenced by _calculateFormulaValue().

                                                                                                  {
                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 PHPExcel_Calculation_Token_Stack;

                //      Loop through each token in turn
                foreach ($tokens as $tokenData) {
//                      print_r($tokenData);
//                      echo '<br />';
                        $token = $tokenData['value'];
//                      echo '<b>Token is '.$token.'</b><br />';
                        // 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])) {
//                              echo 'Token is a binary operator<br />';
                                //      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
                                                $this->_executeBinaryComparisonOperation($cellID,$operand1,$operand2,$token,$stack);
                                                break;
                                        //      Binary Operators
                                        case ':'        :                       //      Range
                                                $sheet1 = $sheet2 = '';
                                                if (strpos($operand1Data['reference'],'!') !== FALSE) {
                                                        list($sheet1,$operand1Data['reference']) = explode('!',$operand1Data['reference']);
                                                } else {
                                                        $sheet1 = ($pCellParent !== NULL) ? $pCellWorksheet->getTitle() : '';
                                                }
                                                if (strpos($operand2Data['reference'],'!') !== FALSE) {
                                                        list($sheet2,$operand2Data['reference']) = explode('!',$operand2Data['reference']);
                                                } else {
                                                        $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 = array();
                                                        foreach($oData as $oDatum) {
                                                                $oCR = PHPExcel_Cell::coordinateFromString($oDatum);
                                                                $oCol[] = PHPExcel_Cell::columnIndexFromString($oCR[0]) - 1;
                                                                $oRow[] = $oCR[1];
                                                        }
                                                        $cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);
                                                        if ($pCellParent !== NULL) {
                                                                $cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($sheet1), FALSE);
                                                        } else {
                                                                return $this->_raiseFormulaError('Unable to access Cell Reference');
                                                        }
                                                        $stack->push('Cell Reference',$cellValue,$cellRef);
                                                } else {
                                                        $stack->push('Error',PHPExcel_Calculation_Functions::REF(),NULL);
                                                }

                                                break;
                                        case '+'        :                       //      Addition
                                                $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'plusEquals',$stack);
                                                break;
                                        case '-'        :                       //      Subtraction
                                                $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'minusEquals',$stack);
                                                break;
                                        case '*'        :                       //      Multiplication
                                                $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayTimesEquals',$stack);
                                                break;
                                        case '/'        :                       //      Division
                                                $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayRightDivide',$stack);
                                                break;
                                        case '^'        :                       //      Exponential
                                                $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'power',$stack);
                                                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 PHPExcel_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 (PHPExcel_Exception $ex) {
                                                                $this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
                                                                $result = '#VALUE!';
                                                        }
                                                } else {
                                                        $result = '"'.str_replace('""','"',self::_unwrapResult($operand1,'"').self::_unwrapResult($operand2,'"')).'"';
                                                }
                                                $this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));
                                                $stack->push('Value',$result);
                                                break;
                                        case '|'        :                       //      Intersect
                                                $rowIntersect = array_intersect_key($operand1,$operand2);
                                                $cellIntersect = $oCol = $oRow = array();
                                                foreach(array_keys($rowIntersect) as $row) {
                                                        $oRow[] = $row;
                                                        foreach($rowIntersect[$row] as $col => $data) {
                                                                $oCol[] = PHPExcel_Cell::columnIndexFromString($col) - 1;
                                                                $cellIntersect[$row] = array_intersect_key($operand1[$row],$operand2[$row]);
                                                        }
                                                }
                                                $cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).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 === '%')) {
//                              echo 'Token is a unary operator<br />';
                                if (($arg = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
                                $arg = $arg['value'];
                                if ($token === '~') {
//                                      echo 'Token is a negation operator<br />';
                                        $this->_debugLog->writeDebugLog('Evaluating Negation of ', $this->_showValue($arg));
                                        $multiplier = -1;
                                } else {
//                                      echo 'Token is a percentile operator<br />';
                                        $this->_debugLog->writeDebugLog('Evaluating Percentile of ', $this->_showValue($arg));
                                        $multiplier = 0.01;
                                }
                                if (is_array($arg)) {
                                        self::_checkMatrixOperands($arg,$multiplier,2);
                                        try {
                                                $matrix1 = new PHPExcel_Shared_JAMA_Matrix($arg);
                                                $matrixResult = $matrix1->arrayTimesEquals($multiplier);
                                                $result = $matrixResult->getArray();
                                        } catch (PHPExcel_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);
                                } else {
                                        $this->_executeNumericBinaryOperation($cellID,$multiplier,$arg,'*','arrayTimesEquals',$stack);
                                }

                        } elseif (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $token, $matches)) {
                                $cellRef = NULL;
//                              echo 'Element '.$token.' is a Cell reference<br />';
                                if (isset($matches[8])) {
//                                      echo 'Reference is a Range of cells<br />';
                                        if ($pCell === NULL) {
//                                              We can't access the range, so return a REF error
                                                $cellValue = PHPExcel_Calculation_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 workbook (not currently supported)
                                                                return $this->_raiseFormulaError('Unable to access External Workbook');
                                                        }
                                                        $matches[2] = trim($matches[2],"\"'");
//                                                      echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';
                                                        $this->_debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in worksheet ', $matches[2]);
                                                        if ($pCellParent !== NULL) {
                                                                $cellValue = $this->extractCellRange($cellRef, $this->_workbook->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));
//                                                      $cellRef = $matches[2].'!'.$cellRef;
                                                } else {
//                                                      echo '$cellRef='.$cellRef.' in current worksheet<br />';
                                                        $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 {
//                                      echo 'Reference is a single Cell<br />';
                                        if ($pCell === NULL) {
//                                              We can't access the cell, so return a REF error
                                                $cellValue = PHPExcel_Calculation_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 workbook (not currently supported)
                                                                return $this->_raiseFormulaError('Unable to access External Workbook');
                                                        }
//                                                      echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';
                                                        $this->_debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in worksheet ', $matches[2]);
                                                        if ($pCellParent !== NULL) {
                                                                $cellSheet = $this->_workbook->getSheetByName($matches[2]);
                                                                if ($cellSheet && $cellSheet->cellExists($cellRef)) {
                                                                        $cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($matches[2]), FALSE);
                                                                        $pCell->attach($pCellParent);
                                                                } else {
                                                                        $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));
//                                                      $cellRef = $matches[2].'!'.$cellRef;
                                                } else {
//                                                      echo '$cellRef='.$cellRef.' in current worksheet<br />';
                                                        $this->_debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in current worksheet');
                                                        if ($pCellParent->isDataSet($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('Value',$cellValue,$cellRef);

                        // 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.'$/i', $token, $matches)) {
//                              echo 'Token is a function<br />';
                                $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::$_PHPExcelFunctions[$functionName])) || (isset(self::$_controlFunctions[$functionName]))) {    // function
                                        if (isset(self::$_PHPExcelFunctions[$functionName])) {
                                                $functionCall = self::$_PHPExcelFunctions[$functionName]['functionCall'];
                                                $passByReference = isset(self::$_PHPExcelFunctions[$functionName]['passByReference']);
                                                $passCellReference = isset(self::$_PHPExcelFunctions[$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
//                                      echo 'Function '.$functionName.' expects '.$argCount.' arguments<br />';
                                        $args = $argArrayVals = array();
                                        for ($i = 0; $i < $argCount; ++$i) {
                                                $arg = $stack->pop();
                                                $a = $argCount - $i - 1;
                                                if (($passByReference) &&
                                                        (isset(self::$_PHPExcelFunctions[$functionName]['passByReference'][$a])) &&
                                                        (self::$_PHPExcelFunctions[$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);
                                        }
//                                      echo 'Arguments are: ';
//                                      print_r($args);
//                                      echo '<br />';
                                        if ($functionName != 'MKMATRIX') {
                                                if ($this->_debugLog->getWriteDebugLog()) {
                                                        krsort($argArrayVals);
                                                        $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', implode(self::$_localeArgumentSeparator.' ',PHPExcel_Calculation_Functions::flattenArray($argArrayVals)), ' )');
                                                }
                                        }
                                        //      Process each argument in turn, building the return value as an array
//                                      if (($argCount == 1) && (is_array($args[1])) && ($functionName != 'MKMATRIX')) {
//                                              $operand1 = $args[1];
//                                              $this->_debugLog->writeDebugLog('Argument is a matrix: ', $this->_showValue($operand1));
//                                              $result = array();
//                                              $row = 0;
//                                              foreach($operand1 as $args) {
//                                                      if (is_array($args)) {
//                                                              foreach($args as $arg) {
//                                                                      $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($arg), ' )');
//                                                                      $r = call_user_func_array($functionCall,$arg);
//                                                                      $this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));
//                                                                      $result[$row][] = $r;
//                                                              }
//                                                              ++$row;
//                                                      } else {
//                                                              $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($args), ' )');
//                                                              $r = call_user_func_array($functionCall,$args);
//                                                              $this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));
//                                                              $result[] = $r;
//                                                      }
//                                              }
//                                      } else {
                                        //      Process the argument with the appropriate function call
                                                if ($passCellReference) {
                                                        $args[] = $pCell;
                                                }
                                                if (strpos($functionCall,'::') !== FALSE) {
                                                        $result = call_user_func_array(explode('::',$functionCall),$args);
                                                } else {
                                                        foreach($args as &$arg) {
                                                                $arg = PHPExcel_Calculation_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));
                                }

                        } 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);
//                                      echo 'Token is a PHPExcel constant: '.$excelConstant.'<br />';
                                        $stack->push('Constant Value',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} == '"') || ($token{0} == '#')) {
//                                      echo 'Token is a number, boolean, string, null or an Excel error<br />';
                                        $stack->push('Value',$token);
                                // if the token is a named range, push the named range name onto the stack
                                } elseif (preg_match('/^'.self::CALCULATION_REGEXP_NAMEDRANGE.'$/i', $token, $matches)) {
//                                      echo 'Token is a named range<br />';
                                        $namedRange = $matches[6];
//                                      echo 'Named Range is '.$namedRange.'<br />';
                                        $this->_debugLog->writeDebugLog('Evaluating Named Range ', $namedRange);
                                        $cellValue = $this->extractNamedRange($namedRange, ((NULL !== $pCell) ? $pCellWorksheet : NULL), FALSE);
                                        $pCell->attach($pCellParent);
                                        $this->_debugLog->writeDebugLog('Evaluation Result for named range ', $namedRange, ' is ', $this->_showTypeDetails($cellValue));
                                        $stack->push('Named Range',$cellValue,$namedRange);
                                } else {
                                        return $this->_raiseFormulaError("undefined variable '$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'];

//              if ((is_array($output)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {
//                      return array_shift(PHPExcel_Calculation_Functions::flattenArray($output));
//              }
                return $output;
        }       //      function _processTokenStack()

Here is the call graph for this function:

Here is the caller graph for this function:

_raiseFormulaError()

PHPExcel_Calculation::_raiseFormulaError (   $errorMessage )

protected

Definition at line 3731 of file Calculation.php.

Referenced by _calculateFormulaValue(), _convertMatrixReferences(), _parseFormula(), and _processTokenStack().

                                                             {
                $this->formulaError = $errorMessage;
                $this->_cyclicReferenceStack->clear();
                if (!$this->suppressFormulaErrors) throw new PHPExcel_Calculation_Exception($errorMessage);
                trigger_error($errorMessage, E_USER_ERROR);
        }       //      function _raiseFormulaError()

Here is the caller graph for this function:

_resizeMatricesExtend()

static PHPExcel_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
integer	$matrix1Rows	Row size of first matrix operand
integer	$matrix1Columns	Column size of first matrix operand
integer	$matrix2Rows	Row size of second matrix operand
integer	$matrix2Columns	Column size of second matrix operand

Definition at line 2543 of file Calculation.php.

References $x.

                                                                                                                                     {
                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;
                                }
                        }
                }
        }       //      function _resizeMatricesExtend()

_resizeMatricesShrink()

static PHPExcel_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
integer	$matrix1Rows	Row size of first matrix operand
integer	$matrix1Columns	Column size of first matrix operand
integer	$matrix2Rows	Row size of second matrix operand
integer	$matrix2Columns	Column size of second matrix operand

Definition at line 2500 of file Calculation.php.

                                                                                                                                     {
                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]);
                                        }
                                }
                        }
                }
        }       //      function _resizeMatricesShrink()

_showTypeDetails()

PHPExcel_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

mixed

Definition at line 2621 of file Calculation.php.

References _showValue(), and PHPExcel_Calculation_Functions\flattenArray().

Referenced by _executeBinaryComparisonOperation(), _executeNumericBinaryOperation(), _processTokenStack(), and _validateBinaryOperand().

                                                  {
                if ($this->_debugLog->getWriteDebugLog()) {
                        $testArray = PHPExcel_Calculation_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';
                                } else {
                                        $typeString = 'a string';
                                }
                        }
                        return $typeString.' with a value of '.$this->_showValue($value);
                }
        }       //      function _showTypeDetails()

Here is the call graph for this function:

Here is the caller graph for this function:

_showValue()

PHPExcel_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 2586 of file Calculation.php.

References $row, array, PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation_Functions\flattenSingleValue().

Referenced by _executeBinaryComparisonOperation(), _processTokenStack(), and _showTypeDetails().

                                            {
                if ($this->_debugLog->getWriteDebugLog()) {
                        $testArray = PHPExcel_Calculation_Functions::flattenArray($value);
                        if (count($testArray) == 1) {
                                $value = array_pop($testArray);
                        }

                        if (is_array($value)) {
                                $returnMatrix = array();
                                $pad = $rpad = ', ';
                                foreach($value as $row) {
                                        if (is_array($row)) {
                                                $returnMatrix[] = implode($pad,array_map(array($this,'_showValue'),$row));
                                                $rpad = '; ';
                                        } else {
                                                $returnMatrix[] = $this->_showValue($row);
                                        }
                                }
                                return '{ '.implode($rpad,$returnMatrix).' }';
                        } elseif(is_string($value) && (trim($value,'"') == $value)) {
                                return '"'.$value.'"';
                        } elseif(is_bool($value)) {
                                return ($value) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];
                        }
                }
                return PHPExcel_Calculation_Functions::flattenSingleValue($value);
        }       //      function _showValue()

Here is the call graph for this function:

Here is the caller graph for this function:

_translateFormula()

static PHPExcel_Calculation::_translateFormula (   $from,   $to,   $formula,   $fromSeparator,   $toSeparator  )

staticprivate

Definition at line 2055 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,'"') !== 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('"',$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('"',$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;
        }

_translateFormulaToEnglish()

PHPExcel_Calculation::_translateFormulaToEnglish

(

$formula

)

Definition at line 2117 of file Calculation.php.

References array.

                                                             {
                if (self::$functionReplaceFromLocale === NULL) {
                        self::$functionReplaceFromLocale = array();
                        foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {
                                self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($localeFunctionName).'([\s]*\()/Ui';
                        }
                        foreach(array_values(self::$_localeBoolean) as $excelBoolean) {
                                self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($excelBoolean).'([^\w\.])/Ui';
                        }
                }

                if (self::$functionReplaceToExcel === NULL) {
                        self::$functionReplaceToExcel = array();
                        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,',');
        }       //      function _translateFormulaToEnglish()

_translateFormulaToLocale()

PHPExcel_Calculation::_translateFormulaToLocale

(

$formula

)

Definition at line 2088 of file Calculation.php.

References array.

                                                            {
                if (self::$functionReplaceFromExcel === NULL) {
                        self::$functionReplaceFromExcel = array();
                        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 = array();
                        foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {
                                self::$functionReplaceToLocale[] = '$1'.trim($localeFunctionName).'$2';
                        }
                        foreach(array_values(self::$_localeBoolean) as $localeBoolean) {
                                self::$functionReplaceToLocale[] = '$1'.trim($localeBoolean).'$2';
                        }
                }

                return self::_translateFormula(self::$functionReplaceFromExcel,self::$functionReplaceToLocale,$formula,',',self::$_localeArgumentSeparator);
        }       //      function _translateFormulaToLocale()

_translateSeparator()

static PHPExcel_Calculation::_translateSeparator (   $fromSeparator,   $toSeparator,   $formula, &  $inBraces  )

static

Definition at line 2037 of file Calculation.php.

Referenced by PHPExcel_Reader_OOCalc\loadIntoExisting().

                                                                                                    {
                $strlen = mb_strlen($formula);
                for ($i = 0; $i < $strlen; ++$i) {
                        $chr = mb_substr($formula,$i,1);
                        switch ($chr) {
                                case '{' :      $inBraces = TRUE;
                                                        break;
                                case '}' :      $inBraces = FALSE;
                                                        break;
                                case $fromSeparator :
                                                        if (!$inBraces) {
                                                                $formula = mb_substr($formula,0,$i).$toSeparator.mb_substr($formula,$i+1);
                                                        }
                        }
                }
                return $formula;
        }

Here is the caller graph for this function:

_unwrapResult()

static PHPExcel_Calculation::_unwrapResult (   $value )

static

Remove quotes used as a wrapper to identify string values.

Parameters

mixed

$value

Returns

mixed

Definition at line 2187 of file Calculation.php.

References PHPExcel_Calculation_Functions\NaN().

Referenced by PHPExcel_Reader_SYLK\loadIntoExisting(), and PHPExcel_Chart_DataSeriesValues\refresh().

                                                     {
                if (is_string($value)) {
                        if ((isset($value{0})) && ($value{0} == '"') && (substr($value,-1) == '"')) {
                                return substr($value,1,-1);
                        }
                //      Convert numeric errors to NaN error
                } else if((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
                        return PHPExcel_Calculation_Functions::NaN();
                }
                return $value;
        }       //      function _unwrapResult()

Here is the call graph for this function:

Here is the caller graph for this function:

_validateBinaryOperand()

PHPExcel_Calculation::_validateBinaryOperand (   $cellID, &  $operand, &  $stack  )

private

Definition at line 3498 of file Calculation.php.

References _showTypeDetails(), and PHPExcel_Shared_String\convertToNumberIfFraction().

Referenced by _executeNumericBinaryOperation().

                                                                             {
                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} == '"') { $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 (!PHPExcel_Shared_String::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('Value', '#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;
        }       //      function _validateBinaryOperand()

Here is the call graph for this function:

Here is the caller graph for this function:

_wrapResult()

static PHPExcel_Calculation::_wrapResult (   $value )

static

Wrap string values in quotes.

Parameters

mixed

$value

Returns

mixed

Definition at line 2163 of file Calculation.php.

References PHPExcel_Calculation_Functions\NaN().

Referenced by PHPExcel_Calculation_Database\__filter(), PHPExcel_Calculation_Functions\_ifCondition(), PHPExcel_Calculation_Statistical\AVERAGEIF(), PHPExcel_Calculation_Statistical\COUNTIF(), PHPExcel_Calculation_Statistical\MAXIF(), PHPExcel_Calculation_Statistical\MINIF(), and PHPExcel_Calculation_MathTrig\SUMIF().

                                                   {
                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 '"'.$value.'"';
                //      Convert numeric errors to NaN error
                } else if((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
                        return PHPExcel_Calculation_Functions::NaN();
                }

                return $value;
        }       //      function _wrapResult()

Here is the call graph for this function:

Here is the caller graph for this function:

calculate()

PHPExcel_Calculation::calculate

(

PHPExcel_Cell

$pCell = NULL

)

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

public

Parameters

PHPExcel_Cell

$pCell

Cell to calculate

Returns

mixed

Exceptions

PHPExcel_Calculation_Exception

Definition at line 2211 of file Calculation.php.

References calculateCellValue().

                                                               {
                try {
                        return $this->calculateCellValue($pCell);
                } catch (PHPExcel_Exception $e) {
                        throw new PHPExcel_Calculation_Exception($e->getMessage());
                }
        }       //      function calculate()

Here is the call graph for this function:

calculateCellValue()

PHPExcel_Calculation::calculateCellValue	(	PHPExcel_Cell	$pCell = NULL,
			$resetLog = TRUE
	)

Calculate the value of a cell formula.

public

Parameters

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

Returns

mixed

Exceptions

PHPExcel_Calculation_Exception

Definition at line 2229 of file Calculation.php.

References $r, $result, $returnArrayAsType, _calculateFormulaValue(), array, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by calculate().

                                                                                          {
                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->_cyclicFormulaCount = 1;

                        self::$returnArrayAsType = self::RETURN_ARRAY_AS_ARRAY;
                }

                //      Execute the calculation for the cell formula
        $this->_cellStack[] = array(
            'sheet' => $pCell->getWorksheet()->getTitle(),
            'cell' => $pCell->getCoordinate(),
        );
                try {
                        $result = self::_unwrapResult($this->_calculateFormulaValue($pCell->getValue(), $pCell->getCoordinate(), $pCell));
            $cellAddress = array_pop($this->_cellStack);
            $this->_workbook->getSheetByName($cellAddress['sheet'])->getCell($cellAddress['cell']);
                } catch (PHPExcel_Exception $e) {
            $cellAddress = array_pop($this->_cellStack);
            $this->_workbook->getSheetByName($cellAddress['sheet'])->getCell($cellAddress['cell']);
                        throw new PHPExcel_Calculation_Exception($e->getMessage());
                }

                if ((is_array($result)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {
                        self::$returnArrayAsType = $returnArrayAsType;
                        $testResult = PHPExcel_Calculation_Functions::flattenArray($result);
                        if (self::$returnArrayAsType == self::RETURN_ARRAY_AS_ERROR) {
                                return PHPExcel_Calculation_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 PHPExcel_Calculation_Functions::VALUE(); }
                                if (is_array($result[$r])) {
                                        $c = array_keys($result[$r]);
                                        $c = array_shift($c);
                                        if (!is_numeric($c)) {
                                                return PHPExcel_Calculation_Functions::VALUE();
                                        }
                                }
                        }
                        $result = array_shift($testResult);
                }
                self::$returnArrayAsType = $returnArrayAsType;


                if ($result === NULL) {
                        return 0;
                } elseif((is_float($result)) && ((is_nan($result)) || (is_infinite($result)))) {
                        return PHPExcel_Calculation_Functions::NaN();
                }
                return $result;
        }       //      function calculateCellValue(

Here is the call graph for this function:

Here is the caller graph for this function:

calculateFormula()

PHPExcel_Calculation::calculateFormula	(		$formula,
			$cellID = NULL,
		PHPExcel_Cell	$pCell = NULL
	)

Calculate the value of a formula.

Parameters

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

Returns

mixed

Exceptions

PHPExcel_Calculation_Exception

Definition at line 2323 of file Calculation.php.

References $result, _calculateFormulaValue(), and getCalculationCacheEnabled().

                                                                                              {
                //      Initialise the logging settings
                $this->formulaError = null;
                $this->_debugLog->clearLog();
                $this->_cyclicReferenceStack->clear();

                //      Disable calculation cacheing because it only applies to cell calculations, not straight formulae
                //      But don't actually flush any cache
                $resetCache = $this->getCalculationCacheEnabled();
                $this->_calculationCacheEnabled = FALSE;
                //      Execute the calculation
                try {
                        $result = self::_unwrapResult($this->_calculateFormulaValue($formula, $cellID, $pCell));
                } catch (PHPExcel_Exception $e) {
                        throw new PHPExcel_Calculation_Exception($e->getMessage());
                }

                //      Reset calculation cacheing to its previous state
                $this->_calculationCacheEnabled = $resetCache;

                return $result;
        }       //      function calculateFormula()

Here is the call graph for this function:

clearCalculationCache()

PHPExcel_Calculation::clearCalculationCache

(

)

Clear calculation cache.

Definition at line 1917 of file Calculation.php.

References array.

Referenced by flushInstance(), and setCalculationCacheEnabled().

                                                {
                $this->_calculationCache = array();
        }       //      function clearCalculationCache()

Here is the caller graph for this function:

clearCalculationCacheForWorksheet()

PHPExcel_Calculation::clearCalculationCacheForWorksheet

(

$worksheetName

)

Clear calculation cache for a specified worksheet.

Parameters

string

$worksheetName

Definition at line 1926 of file Calculation.php.

                                                                          {
                if (isset($this->_calculationCache[$worksheetName])) {
                        unset($this->_calculationCache[$worksheetName]);
                }
        }       //      function clearCalculationCacheForWorksheet()

disableCalculationCache()

PHPExcel_Calculation::disableCalculationCache

(

)

Disable calculation cache.

Definition at line 1909 of file Calculation.php.

References setCalculationCacheEnabled().

                                                  {
                $this->setCalculationCacheEnabled(FALSE);
        }       //      function disableCalculationCache()

Here is the call graph for this function:

enableCalculationCache()

PHPExcel_Calculation::enableCalculationCache

(

)

Enable calculation cache.

Definition at line 1901 of file Calculation.php.

References setCalculationCacheEnabled().

                                                 {
                $this->setCalculationCacheEnabled(TRUE);
        }       //      function enableCalculationCache()

Here is the call graph for this function:

extractCellRange()

PHPExcel_Calculation::extractCellRange	(	&	$pRange = 'A1',
		PHPExcel_Worksheet	$pSheet = NULL,
			$resetLog = TRUE
	)

Extract range values.

Parameters

string	&$pRange	String based range representation
PHPExcel_Worksheet	$pSheet	Worksheet
boolean	$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.

Exceptions

PHPExcel_Calculation_Exception

Definition at line 3748 of file Calculation.php.

References array, PHPExcel_Cell\extractAllCellReferencesInRange(), and PHPExcel_Worksheet\extractSheetTitle().

Referenced by _processTokenStack().

                                                                                                               {
                // Return value
                $returnValue = array ();

//              echo 'extractCellRange('.$pRange.')',PHP_EOL;
                if ($pSheet !== NULL) {
                        $pSheetName = $pSheet->getTitle();
//                      echo 'Passed sheet name is '.$pSheetName.PHP_EOL;
//                      echo 'Range reference is '.$pRange.PHP_EOL;
                        if (strpos ($pRange, '!') !== false) {
//                              echo '$pRange reference includes sheet reference',PHP_EOL;
                                list($pSheetName,$pRange) = PHPExcel_Worksheet::extractSheetTitle($pRange, true);
//                              echo 'New sheet name is '.$pSheetName,PHP_EOL;
//                              echo 'Adjusted Range reference is '.$pRange,PHP_EOL;
                                $pSheet = $this->_workbook->getSheetByName($pSheetName);
                        }

                        // Extract range
                        $aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);
                        $pRange = $pSheetName.'!'.$pRange;
                        if (!isset($aReferences[1])) {
                                //      Single cell in range
                                sscanf($aReferences[0],'%[A-Z]%d', $currentCol, $currentRow);
                                $cellValue = NULL;
                                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
                                        sscanf($reference,'%[A-Z]%d', $currentCol, $currentRow);
                                        $cellValue = NULL;
                                        if ($pSheet->cellExists($reference)) {
                                                $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
                                        } else {
                                                $returnValue[$currentRow][$currentCol] = NULL;
                                        }
                                }
                        }
                }

                // Return
                return $returnValue;
        }       //      function extractCellRange()

Here is the call graph for this function:

Here is the caller graph for this function:

extractNamedRange()

PHPExcel_Calculation::extractNamedRange	(	&	$pRange = 'A1',
		PHPExcel_Worksheet	$pSheet = NULL,
			$resetLog = TRUE
	)

Extract range values.

Parameters

string	&$pRange	String based range representation
PHPExcel_Worksheet	$pSheet	Worksheet

Returns

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

Parameters

boolean

$resetLog

Flag indicating whether calculation log should be reset or not

Exceptions

PHPExcel_Calculation_Exception

Definition at line 3806 of file Calculation.php.

References array, PHPExcel_Cell\coordinateFromString(), PHPExcel_Cell\extractAllCellReferencesInRange(), PHPExcel_Worksheet\extractSheetTitle(), PHPExcel_Calculation_Functions\REF(), PHPExcel_NamedRange\resolveRange(), and PHPExcel_Cell\splitRange().

Referenced by _processTokenStack().

                                                                                                                {
                // Return value
                $returnValue = array ();

//              echo 'extractNamedRange('.$pRange.')<br />';
                if ($pSheet !== NULL) {
                        $pSheetName = $pSheet->getTitle();
//                      echo 'Current sheet name is '.$pSheetName.'<br />';
//                      echo 'Range reference is '.$pRange.'<br />';
                        if (strpos ($pRange, '!') !== false) {
//                              echo '$pRange reference includes sheet reference',PHP_EOL;
                                list($pSheetName,$pRange) = PHPExcel_Worksheet::extractSheetTitle($pRange, true);
//                              echo 'New sheet name is '.$pSheetName,PHP_EOL;
//                              echo 'Adjusted Range reference is '.$pRange,PHP_EOL;
                                $pSheet = $this->_workbook->getSheetByName($pSheetName);
                        }

                        // Named range?
                        $namedRange = PHPExcel_NamedRange::resolveRange($pRange, $pSheet);
                        if ($namedRange !== NULL) {
                                $pSheet = $namedRange->getWorksheet();
//                              echo 'Named Range '.$pRange.' (';
                                $pRange = $namedRange->getRange();
                                $splitRange = PHPExcel_Cell::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];
                                }
//                              echo $pRange.') is in sheet '.$namedRange->getWorksheet()->getTitle().'<br />';

//                              if ($pSheet->getTitle() != $namedRange->getWorksheet()->getTitle()) {
//                                      if (!$namedRange->getLocalOnly()) {
//                                              $pSheet = $namedRange->getWorksheet();
//                                      } else {
//                                              return $returnValue;
//                                      }
//                              }
                        } else {
                                return PHPExcel_Calculation_Functions::REF();
                        }

                        // Extract range
                        $aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);
//                      var_dump($aReferences);
                        if (!isset($aReferences[1])) {
                                //      Single cell (or single column or row) in range
                                list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($aReferences[0]);
                                $cellValue = NULL;
                                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
                                        list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($reference);
//                                      echo 'NAMED RANGE: $currentCol='.$currentCol.' $currentRow='.$currentRow.'<br />';
                                        $cellValue = NULL;
                                        if ($pSheet->cellExists($reference)) {
                                                $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
                                        } else {
                                                $returnValue[$currentRow][$currentCol] = NULL;
                                        }
                                }
                        }
//                              print_r($returnValue);
//                      echo '<br />';
                }

                // Return
                return $returnValue;
        }       //      function extractNamedRange()

Here is the call graph for this function:

Here is the caller graph for this function:

flushInstance()

PHPExcel_Calculation::flushInstance

(

)

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

public

Returns

null

Definition at line 1801 of file Calculation.php.

References clearCalculationCache().

                                        {
                $this->clearCalculationCache();
        }       //      function flushInstance()

Here is the call graph for this function:

getArrayReturnType()

static PHPExcel_Calculation::getArrayReturnType ( )

static

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

public

Returns

string $returnType Array return type

Definition at line 1871 of file Calculation.php.

Referenced by PHPExcel_Writer_PDF_Core\prepareForSave(), PHPExcel_Writer_CSV\save(), and PHPExcel_Writer_HTML\save().

                                                    {
                return self::$returnArrayAsType;
        }       //      function getArrayReturnType()

Here is the caller graph for this function:

getCalculationCacheEnabled()

PHPExcel_Calculation::getCalculationCacheEnabled

(

)

Is calculation caching enabled?

public

Returns

boolean

Definition at line 1882 of file Calculation.php.

References $_calculationCacheEnabled.

Referenced by calculateFormula().

                                                     {
                return $this->_calculationCacheEnabled;
        }       //      function getCalculationCacheEnabled()

Here is the caller graph for this function:

getDebugLog()

PHPExcel_Calculation::getDebugLog

(

)

Get the debuglog for this claculation engine instance.

public

Returns

PHPExcel_CalcEngine_Logger

Definition at line 1812 of file Calculation.php.

                                      {
                return $this->_debugLog;
        }

getFALSE()

static PHPExcel_Calculation::getFALSE ( )

static

Return the locale-specific translation of FALSE.

public

Returns

string locale-specific translation of FALSE

Definition at line 1843 of file Calculation.php.

Referenced by PHPExcel_Calculation_TextData\ASCIICODE(), PHPExcel_Cell_AdvancedValueBinder\bindValue(), PHPExcel_Calculation_TextData\CONCATENATE(), PHPExcel_Calculation_TextData\LEFT(), PHPExcel_Calculation_Logical\LOGICAL_AND(), PHPExcel_Calculation_Logical\LOGICAL_OR(), PHPExcel_Calculation_TextData\LOWERCASE(), PHPExcel_Calculation_TextData\MID(), PHPExcel_Calculation_Logical\NOT(), PHPExcel_Calculation_TextData\PROPERCASE(), PHPExcel_Calculation_TextData\RIGHT(), PHPExcel_Calculation_TextData\SEARCHINSENSITIVE(), PHPExcel_Calculation_TextData\SEARCHSENSITIVE(), PHPExcel_Calculation_TextData\STRINGLENGTH(), PHPExcel_Calculation_TextData\TRIMNONPRINTABLE(), PHPExcel_Calculation_TextData\TRIMSPACES(), and PHPExcel_Calculation_TextData\UPPERCASE().

                                          {
                return self::$_localeBoolean['FALSE'];
        }

Here is the caller graph for this function:

getInstance()

static PHPExcel_Calculation::getInstance ( PHPExcel  $workbook = NULL )

static

Get an instance of this class.

public

Parameters

PHPExcel

$workbook

Injected workbook for working with a PHPExcel object, or NULL to create a standalone claculation engine

Returns

PHPExcel_Calculation

Definition at line 1765 of file Calculation.php.

Referenced by PHPExcel\__construct(), PHPExcel_Worksheet\__destruct(), PHPExcel_Calculation_Database\__filter(), PHPExcel_Calculation_Statistical\AVERAGEIF(), PHPExcel_Shared_String\convertToNumberIfFraction(), PHPExcel_Calculation_Statistical\COUNTIF(), PHPExcel_Cell\getCalculatedValue(), PHPExcel_Calculation_LookupRef\INDIRECT(), PHPExcel_Calculation_Statistical\MAXIF(), PHPExcel_Calculation_Statistical\MINIF(), PHPExcel_Calculation_LookupRef\OFFSET(), PHPExcel_Chart_DataSeriesValues\refresh(), PHPExcel_Writer_CSV\save(), PHPExcel_Writer_Excel5\save(), PHPExcel_Writer_HTML\save(), PHPExcel_Writer_Excel2007\save(), PHPExcel_Settings\setLocale(), PHPExcel_Worksheet\setTitle(), PHPExcel_Worksheet_AutoFilter\showHideRows(), PHPExcel_Calculation_MathTrig\SUMIF(), and CalculationTest\testBinaryComparisonOperation().

                                                                      {
                if ($workbook !== NULL) {
                if (isset(self::$_workbookSets[$workbook->getID()])) {
                        return self::$_workbookSets[$workbook->getID()];
                }
                        return new PHPExcel_Calculation($workbook);
                }

                if (!isset(self::$_instance) || (self::$_instance === NULL)) {
                        self::$_instance = new PHPExcel_Calculation();
                }

                return self::$_instance;
        }       //      function getInstance()

Here is the caller graph for this function:

getLocale()

PHPExcel_Calculation::getLocale

(

)

Get the currently defined locale code.

Returns

string

Definition at line 1951 of file Calculation.php.

                                    {
                return self::$_localeLanguage;
        }       //      function getLocale()

getTRUE()

static PHPExcel_Calculation::getTRUE ( )

static

Return the locale-specific translation of TRUE.

public

Returns

string locale-specific translation of TRUE

Definition at line 1833 of file Calculation.php.

Referenced by PHPExcel_Calculation_TextData\ASCIICODE(), PHPExcel_Cell_AdvancedValueBinder\bindValue(), PHPExcel_Calculation_TextData\CONCATENATE(), PHPExcel_Calculation_TextData\LEFT(), PHPExcel_Calculation_Logical\LOGICAL_AND(), PHPExcel_Calculation_Logical\LOGICAL_OR(), PHPExcel_Calculation_TextData\LOWERCASE(), PHPExcel_Calculation_TextData\MID(), PHPExcel_Calculation_Logical\NOT(), PHPExcel_Calculation_TextData\PROPERCASE(), PHPExcel_Calculation_TextData\RIGHT(), PHPExcel_Calculation_TextData\SEARCHINSENSITIVE(), PHPExcel_Calculation_TextData\SEARCHSENSITIVE(), PHPExcel_Calculation_TextData\STRINGLENGTH(), PHPExcel_Calculation_TextData\TRIMNONPRINTABLE(), PHPExcel_Calculation_TextData\TRIMSPACES(), and PHPExcel_Calculation_TextData\UPPERCASE().

                                         {
                return self::$_localeBoolean['TRUE'];
        }

Here is the caller graph for this function:

getValueFromCache()

PHPExcel_Calculation::getValueFromCache	(		$cellReference,
		&	$cellValue
	)

Definition at line 2347 of file Calculation.php.

Referenced by _calculateFormulaValue().

                                                                   {
                // Is calculation cacheing enabled?
                // Is the value present in calculation cache?
                $this->_debugLog->writeDebugLog('Testing cache value for cell ', $cellReference);
                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;
    }

Here is the caller graph for this function:

isImplemented()

PHPExcel_Calculation::isImplemented

(

$pFunction = ''

)

Is a specific function implemented?

Parameters

string

$pFunction

Function Name

Returns

boolean

Definition at line 3890 of file Calculation.php.

                                                       {
                $pFunction = strtoupper ($pFunction);
                if (isset(self::$_PHPExcelFunctions[$pFunction])) {
                        return (self::$_PHPExcelFunctions[$pFunction]['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY');
                } else {
                        return FALSE;
                }
        }       //      function isImplemented()

listAllFunctionNames()

PHPExcel_Calculation::listAllFunctionNames

(

)

Get a list of all Excel function names.

Returns

array

Definition at line 3928 of file Calculation.php.

                                               {
                return array_keys(self::$_PHPExcelFunctions);
        }       //      function listAllFunctionNames()

listFunctionNames()

PHPExcel_Calculation::listFunctionNames

(

)

Get a list of implemented Excel function names.

Returns

array

Definition at line 3937 of file Calculation.php.

References array.

                                            {
                // Return value
                $returnValue = array();
                // Loop functions
                foreach(self::$_PHPExcelFunctions as $functionName => $function) {
                        if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {
                                $returnValue[] = $functionName;
                        }
                }

                // Return
                return $returnValue;
        }       //      function listFunctionNames()

listFunctions()

PHPExcel_Calculation::listFunctions

(

)

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

Returns

array of PHPExcel_Calculation_Function

Definition at line 3905 of file Calculation.php.

References array.

                                        {
                // Return value
                $returnValue = array();
                // Loop functions
                foreach(self::$_PHPExcelFunctions as $functionName => $function) {
                        if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {
                                $returnValue[$functionName] = new PHPExcel_Calculation_Function($function['category'],
                                                                                                                                                                $functionName,
                                                                                                                                                                $function['functionCall']
                                                                                                                                                           );
                        }
                }

                // Return
                return $returnValue;
        }       //      function listFunctions()

parseFormula()

PHPExcel_Calculation::parseFormula

(

$formula

)

Validate and parse a formula string.

Parameters

string

$formula

Formula to parse

Returns

array

Exceptions

PHPExcel_Calculation_Exception

Definition at line 2301 of file Calculation.php.

References _parseFormula(), and array.

                                               {
                //      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 array();
                $formula = ltrim(substr($formula,1));
                if (!isset($formula{0})) return array();

                //      Parse the formula and return the token stack
                return $this->_parseFormula($formula);
        }       //      function parseFormula()

Here is the call graph for this function:

renameCalculationCacheForWorksheet()

PHPExcel_Calculation::renameCalculationCacheForWorksheet	(		$fromWorksheetName,
			$toWorksheetName
	)

Rename calculation cache for a specified worksheet.

Parameters

string	$fromWorksheetName
string	$toWorksheetName

Definition at line 1938 of file Calculation.php.

                                                                                                 {
                if (isset($this->_calculationCache[$fromWorksheetName])) {
                        $this->_calculationCache[$toWorksheetName] = &$this->_calculationCache[$fromWorksheetName];
                        unset($this->_calculationCache[$fromWorksheetName]);
                }
        }       //      function renameCalculationCacheForWorksheet()

saveValueToCache()

PHPExcel_Calculation::saveValueToCache	(		$cellReference,
			$cellValue
	)

Definition at line 2360 of file Calculation.php.

Referenced by _calculateFormulaValue().

                                                                 {
                if ($this->_calculationCacheEnabled) {
                        $this->_calculationCache[$cellReference] = $cellValue;
                }
        }

Here is the caller graph for this function:

setArrayReturnType()

static PHPExcel_Calculation::setArrayReturnType (   $returnType )

static

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

public

Parameters

string

$returnType

Array return type

Returns

boolean Success or failure

Definition at line 1854 of file Calculation.php.

Referenced by PHPExcel_Writer_PDF_Core\prepareForSave(), PHPExcel_Writer_PDF_Core\restoreStateAfterSave(), PHPExcel_Writer_CSV\save(), PHPExcel_Writer_HTML\save(), and MathTrigTest\testMROUND().

                                                               {
                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;
        }       //      function setArrayReturnType()

Here is the caller graph for this function:

setCalculationCacheEnabled()

PHPExcel_Calculation::setCalculationCacheEnabled

(

$pValue = TRUE

)

Enable/disable calculation cache.

public

Parameters

boolean

$pValue

Definition at line 1892 of file Calculation.php.

References clearCalculationCache().

Referenced by disableCalculationCache(), and enableCalculationCache().

                                                                   {
                $this->_calculationCacheEnabled = $pValue;
                $this->clearCalculationCache();
        }       //      function setCalculationCacheEnabled()

Here is the call graph for this function:

Here is the caller graph for this function:

setLocale()

PHPExcel_Calculation::setLocale

(

$locale = 'en_us'

)

Set the locale code.

Parameters

string

$locale

The locale to use for formula translation

Returns

boolean

Definition at line 1962 of file Calculation.php.

References array, and file.

                                                     {
                //      Identify our locale and language
                $language = $locale = strtolower($locale);
                if (strpos($locale,'_') !== FALSE) {
                        list($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 = array();
                        self::$_localeArgumentSeparator = ',';
                        self::$_localeBoolean = array('TRUE' => 'TRUE', 'FALSE' => 'FALSE', 'NULL' => 'NULL');
                        //      Default is English, if user isn't requesting english, then read the necessary data from the locale files
                        if ($locale != 'en_us') {
                                //      Search for a file with a list of function names for locale
                                $functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'functions';
                                if (!file_exists($functionNamesFile)) {
                                        //      If there isn't a locale specific function file, look for a language specific function file
                                        $functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'functions';
                                        if (!file_exists($functionNamesFile)) {
                                                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) {
                                        list($localeFunction) = explode('##',$localeFunction);  //      Strip out comments
                                        if (strpos($localeFunction,'=') !== FALSE) {
                                                list($fName,$lfName) = explode('=',$localeFunction);
                                                $fName = trim($fName);
                                                $lfName = trim($lfName);
                                                if ((isset(self::$_PHPExcelFunctions[$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']; }

                                $configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'config';
                                if (!file_exists($configFile)) {
                                        $configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'config';
                                }
                                if (file_exists($configFile)) {
                                        $localeSettings = file($configFile,FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
                                        foreach ($localeSettings as $localeSetting) {
                                                list($localeSetting) = explode('##',$localeSetting);    //      Strip out comments
                                                if (strpos($localeSetting,'=') !== FALSE) {
                                                        list($settingName,$settingValue) = explode('=',$localeSetting);
                                                        $settingName = strtoupper(trim($settingName));
                                                        switch ($settingName) {
                                                                case 'ARGUMENTSEPARATOR' :
                                                                        self::$_localeArgumentSeparator = trim($settingValue);
                                                                        break;
                                                        }
                                                }
                                        }
                                }
                        }

                        self::$functionReplaceFromExcel = self::$functionReplaceToExcel =
                        self::$functionReplaceFromLocale = self::$functionReplaceToLocale = NULL;
                        self::$_localeLanguage = $locale;
                        return TRUE;
                }
                return FALSE;
        }       //      function setLocale()

strcmpLowercaseFirst()

PHPExcel_Calculation::strcmpLowercaseFirst (   $str1,   $str2  )

private

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

Parameters

string	$str1	First string value for the comparison
string	$str2	Second string value for the comparison

Returns

integer

Definition at line 3653 of file Calculation.php.

References PHPExcel_Shared_String\StrCaseReverse().

Referenced by _executeBinaryComparisonOperation().

        {
        $inversedStr1 = PHPExcel_Shared_String::StrCaseReverse($str1);
        $inversedStr2 = PHPExcel_Shared_String::StrCaseReverse($str2);

                return strcmp($inversedStr1, $inversedStr2);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

unsetInstance()

static PHPExcel_Calculation::unsetInstance ( PHPExcel  $workbook = NULL )

static

Unset an instance of this class.

public

Parameters

PHPExcel

$workbook

Injected workbook identifying the instance to unset

Definition at line 1786 of file Calculation.php.

Referenced by PHPExcel\__destruct().

                                                                        {
                if ($workbook !== NULL) {
                if (isset(self::$_workbookSets[$workbook->getID()])) {
                        unset(self::$_workbookSets[$workbook->getID()]);
                }
                }
    }

Here is the caller graph for this function:

Field Documentation

$_binaryOperators

PHPExcel_Calculation::$_binaryOperators

staticprivate

Initial value:

= array('+' => TRUE,    '-' => TRUE,    '*' => TRUE,    '/' => TRUE,
                                                                                                '^' => TRUE,    '&' => TRUE,    '>' => TRUE,    '<' => TRUE,
                                                                                                '=' => TRUE,    '>=' => TRUE,   '<=' => TRUE,   '<>' => TRUE,
                                                                                                '|' => TRUE,    ':' => TRUE
                                                                                           )

Definition at line 153 of file Calculation.php.

$_calculationCache

PHPExcel_Calculation::$_calculationCache = array ()

private

Definition at line 121 of file Calculation.php.

$_calculationCacheEnabled

PHPExcel_Calculation::$_calculationCacheEnabled = TRUE

private

Definition at line 130 of file Calculation.php.

Referenced by getCalculationCacheEnabled().

$_cellStack

PHPExcel_Calculation::$_cellStack = array()

private

Definition at line 197 of file Calculation.php.

$_comparisonOperators

PHPExcel_Calculation::$_comparisonOperators = array('>' => TRUE, '<' => TRUE, '=' => TRUE, '>=' => TRUE, '<=' => TRUE, '<>' => TRUE)

staticprivate

Definition at line 2722 of file Calculation.php.

$_controlFunctions

PHPExcel_Calculation::$_controlFunctions

staticprivate

Initial value:

= array(
                                'MKMATRIX'      => array('argumentCount'        =>      '*',
                                                                         'functionCall'         =>      'self::_mkMatrix'
                                                                        )
                        )

Definition at line 1714 of file Calculation.php.

$_cyclicFormulaCell

PHPExcel_Calculation::$_cyclicFormulaCell = ''

private

Definition at line 209 of file Calculation.php.

$_cyclicFormulaCount

PHPExcel_Calculation::$_cyclicFormulaCount = 1

private

Definition at line 207 of file Calculation.php.

Referenced by _calculateFormulaValue().

$_cyclicReferenceStack

PHPExcel_Calculation::$_cyclicReferenceStack

private

Definition at line 195 of file Calculation.php.

$_ExcelConstants

PHPExcel_Calculation::$_ExcelConstants

staticprivate

Initial value:

= array('TRUE'  => TRUE,
                                                                                        'FALSE' => FALSE,
                                                                                        'NULL'  => NULL
                                                                                   )

Definition at line 273 of file Calculation.php.

$_instance

PHPExcel_Calculation::$_instance

staticprivate

Definition at line 96 of file Calculation.php.

$_localeArgumentSeparator

PHPExcel_Calculation::$_localeArgumentSeparator = ','

staticprivate

Definition at line 251 of file Calculation.php.

$_localeBoolean

PHPExcel_Calculation::$_localeBoolean

static

Initial value:

= array(        'TRUE'  => 'TRUE',
                                                                                        'FALSE' => 'FALSE',
                                                                                        'NULL'  => 'NULL'
                                                                                  )

Definition at line 260 of file Calculation.php.

$_localeFunctions

PHPExcel_Calculation::$_localeFunctions = array()

staticprivate

Definition at line 252 of file Calculation.php.

$_localeLanguage

PHPExcel_Calculation::$_localeLanguage = 'en_us'

staticprivate

Definition at line 234 of file Calculation.php.

$_operatorAssociativity

PHPExcel_Calculation::$_operatorAssociativity

staticprivate

Initial value:

= array(
                '^' => 0,                                                                                                                       
                '*' => 0, '/' => 0,                                                                                             
                '+' => 0, '-' => 0,                                                                                                     
                '&' => 0,                                                                                                                       
                '|' => 0, ':' => 0,                                                                                                     
                '>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0           
        )

Definition at line 2711 of file Calculation.php.

$_operatorPrecedence

PHPExcel_Calculation::$_operatorPrecedence

staticprivate

Initial value:

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

Definition at line 2727 of file Calculation.php.

$_operators

PHPExcel_Calculation::$_operators

staticprivate

Initial value:

= array('+' => TRUE,    '-' => TRUE,    '*' => TRUE,    '/' => TRUE,
                                                                                                '^' => TRUE,    '&' => TRUE,    '%' => FALSE,   '~' => FALSE,
                                                                                                '>' => TRUE,    '<' => TRUE,    '=' => TRUE,    '>=' => TRUE,
                                                                                                '<=' => TRUE,   '<>' => TRUE,   '|' => TRUE,    ':' => TRUE
                                                                                           )

Definition at line 140 of file Calculation.php.

$_PHPExcelFunctions

PHPExcel_Calculation::$_PHPExcelFunctions

staticprivate

Definition at line 279 of file Calculation.php.

$_savedPrecision

PHPExcel_Calculation::$_savedPrecision = 14

private

Definition at line 225 of file Calculation.php.

$_validLocaleLanguages

PHPExcel_Calculation::$_validLocaleLanguages

staticprivate

Initial value:

= array(        'en'            
                                                                                                 )

Definition at line 243 of file Calculation.php.

$_workbook

PHPExcel_Calculation::$_workbook

private

Definition at line 105 of file Calculation.php.

$_workbookSets

PHPExcel_Calculation::$_workbookSets

staticprivate

Definition at line 113 of file Calculation.php.

$cyclicFormulaCount

PHPExcel_Calculation::$cyclicFormulaCount = 1

Definition at line 217 of file Calculation.php.

$debugLog

PHPExcel_Calculation::$debugLog

private

Definition at line 166 of file Calculation.php.

$formulaError

PHPExcel_Calculation::$formulaError = NULL

Definition at line 186 of file Calculation.php.

$functionReplaceFromExcel

PHPExcel_Calculation::$functionReplaceFromExcel = NULL

staticprivate

Definition at line 2085 of file Calculation.php.

$functionReplaceFromLocale

PHPExcel_Calculation::$functionReplaceFromLocale = NULL

staticprivate

Definition at line 2114 of file Calculation.php.

$functionReplaceToExcel

PHPExcel_Calculation::$functionReplaceToExcel = NULL

staticprivate

Definition at line 2115 of file Calculation.php.

$functionReplaceToLocale

PHPExcel_Calculation::$functionReplaceToLocale = NULL

staticprivate

Definition at line 2086 of file Calculation.php.

$returnArrayAsType

PHPExcel_Calculation::$returnArrayAsType = self::RETURN_ARRAY_AS_VALUE

staticprivate

Definition at line 87 of file Calculation.php.

Referenced by calculateCellValue().

$suppressFormulaErrors

PHPExcel_Calculation::$suppressFormulaErrors = FALSE

Definition at line 177 of file Calculation.php.

CALCULATION_REGEXP_CELLREF

const PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF = CALCULATION_REGEXP_CELLREF

Definition at line 75 of file Calculation.php.

Referenced by PHPExcel_Worksheet\cellExists(), PHPExcel_Worksheet\getCell(), and PHPExcel_Calculation_LookupRef\INDIRECT().

CALCULATION_REGEXP_ERROR

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

Definition at line 79 of file Calculation.php.

CALCULATION_REGEXP_FUNCTION

const PHPExcel_Calculation::CALCULATION_REGEXP_FUNCTION = '@?([A-Z][A-Z0-9\.]*)[\s]*\('

Definition at line 73 of file Calculation.php.

CALCULATION_REGEXP_NAMEDRANGE

const PHPExcel_Calculation::CALCULATION_REGEXP_NAMEDRANGE = CALCULATION_REGEXP_NAMEDRANGE

Definition at line 77 of file Calculation.php.

Referenced by PHPExcel_Worksheet\cellExists(), PHPExcel_Worksheet\getCell(), and PHPExcel_Calculation_LookupRef\INDIRECT().

CALCULATION_REGEXP_NUMBER

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

Constants.

Regular Expressions

Definition at line 67 of file Calculation.php.

Referenced by PHPExcel_Cell_AdvancedValueBinder\bindValue().

CALCULATION_REGEXP_OPENBRACE

const PHPExcel_Calculation::CALCULATION_REGEXP_OPENBRACE = '\('

Definition at line 71 of file Calculation.php.

CALCULATION_REGEXP_STRING

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

Definition at line 69 of file Calculation.php.

RETURN_ARRAY_AS_ARRAY

const PHPExcel_Calculation::RETURN_ARRAY_AS_ARRAY = 'array'

Definition at line 85 of file Calculation.php.

Referenced by MathTrigTest\testMROUND().

RETURN_ARRAY_AS_ERROR

const PHPExcel_Calculation::RETURN_ARRAY_AS_ERROR = 'error'

constants

Definition at line 83 of file Calculation.php.

RETURN_ARRAY_AS_VALUE

const PHPExcel_Calculation::RETURN_ARRAY_AS_VALUE = 'value'

Definition at line 84 of file Calculation.php.

Referenced by PHPExcel_Writer_PDF_Core\prepareForSave(), PHPExcel_Writer_CSV\save(), PHPExcel_Writer_HTML\save(), and MathTrigTest\testMROUND().

---

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

• libs/composer/vendor/phpoffice/phpexcel/Classes/PHPExcel/Calculation.php