| blob | 48fb4a422f2a23f8605c70bb59aae645b022f8f5 |
1 <?php
2 /**
3 * PHPExcel
4 *
5 * Copyright (c) 2006 - 2014 PHPExcel
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 * @category PHPExcel
22 * @package PHPExcel_Calculation
23 * @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
24 * @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
25 * @version ##VERSION##, ##DATE##
26 */
29 /** PHPExcel root directory */
31 /**
32 * @ignore
33 */
36 }
40 // Test for support of \P (multibyte options) in PCRE
42 // Cell reference (cell or range of cells, with or without a sheet reference)
43 define('CALCULATION_REGEXP_CELLREF','((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d{1,7})');
44 // Named Range of cells
45 define('CALCULATION_REGEXP_NAMEDRANGE','((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?([_A-Z][_A-Z0-9\.]*)');
47 // Cell reference (cell or range of cells, with or without a sheet reference)
48 define('CALCULATION_REGEXP_CELLREF','(((\w*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d+)');
49 // Named Range of cells
51 }
52 }
55 /**
56 * PHPExcel_Calculation (Multiton)
57 *
58 * @category PHPExcel
59 * @package PHPExcel_Calculation
60 * @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
61 */
64 /** Constants */
65 /** Regular Expressions */
66 // Numeric operand
68 // String operand
70 // Opening bracket
72 // Function (allow for the old @ symbol that could be used to prefix a function, but we'll ignore it)
74 // Cell reference (cell or range of cells, with or without a sheet reference)
76 // Named Range of cells
78 // Error
82 /** constants */
90 /**
91 * Instance of this class
92 *
93 * @access private
94 * @var PHPExcel_Calculation
95 */
99 /**
100 * Instance of the workbook this Calculation Engine is using
101 *
102 * @access private
103 * @var PHPExcel
104 */
107 /**
108 * List of instances of the calculation engine that we've instantiated for individual workbooks
109 *
110 * @access private
111 * @var PHPExcel_Calculation[]
112 */
115 /**
116 * Calculation cache
117 *
118 * @access private
119 * @var array
120 */
124 /**
125 * Calculation cache enabled
126 *
127 * @access private
128 * @var boolean
129 */
133 /**
134 * List of operators that can be used within formulae
135 * The true/false value indicates whether it is a binary operator or a unary operator
136 *
137 * @access private
138 * @var array
139 */
144 );
147 /**
148 * List of binary operators (those that expect two operands)
149 *
150 * @access private
151 * @var array
152 */
157 );
159 /**
160 * The debug log generated by the calculation engine
161 *
162 * @access private
163 * @var PHPExcel_CalcEngine_Logger
164 *
165 */
168 /**
169 * Flag to determine how formula errors should be handled
170 * If true, then a user error will be triggered
171 * If false, then an exception will be thrown
172 *
173 * @access public
174 * @var boolean
175 *
176 */
179 /**
180 * Error message for any error that was raised/thrown by the calculation engine
181 *
182 * @access public
183 * @var string
184 *
185 */
188 /**
189 * An array of the nested cell references accessed by the calculation engine, used for the debug log
190 *
191 * @access private
192 * @var array of string
193 *
194 */
199 /**
200 * Current iteration counter for cyclic formulae
201 * If the value is 0 (or less) then cyclic formulae will throw an exception,
202 * otherwise they will iterate to the limit defined here before returning a result
203 *
204 * @var integer
205 *
206 */
211 /**
212 * Number of iterations for cyclic formulae
213 *
214 * @var integer
215 *
216 */
219 /**
220 * Precision used for calculations
221 *
222 * @var integer
223 *
224 */
228 /**
229 * The current locale setting
230 *
231 * @var string
232 *
233 */
236 /**
237 * List of available locale settings
238 * Note that this is read for the locale subdirectory only when requested
239 *
240 * @var string[]
241 *
242 */
244 );
245 /**
246 * Locale-specific argument separator for function arguments
247 *
248 * @var string
249 *
250 */
254 /**
255 * Locale-specific translations for Excel constants (True, False and Null)
256 *
257 * @var string[]
258 *
259 */
263 );
266 /**
267 * Excel constant string translations to their PHP equivalents
268 * Constant conversion from text name/value to actual (datatyped) value
269 *
270 * @var string[]
271 *
272 */
276 );
278 // PHPExcel functions
283 ),
287 ),
291 ),
295 ),
299 ),
303 ),
307 ),
311 ),
315 ),
319 ),
323 ),
327 ),
331 ),
335 ),
339 ),
343 ),
347 ),
351 ),
355 ),
359 ),
363 ),
367 ),
371 ),
375 ),
379 ),
383 ),
387 ),
391 ),
395 ),
399 ),
403 ),
407 ),
411 ),
415 ),
419 ),
423 ),
427 ),
431 ),
435 ),
439 ),
443 ),
448 ),
452 ),
456 ),
460 ),
464 ),
468 ),
472 ),
476 ),
480 ),
484 ),
488 ),
492 ),
496 ),
500 ),
504 ),
508 ),
512 ),
516 ),
520 ),
524 ),
528 ),
532 ),
536 ),
540 ),
544 ),
548 ),
552 ),
556 ),
560 ),
564 ),
568 ),
572 ),
576 ),
580 ),
584 ),
588 ),
592 ),
596 ),
600 ),
604 ),
608 ),
612 ),
616 ),
620 ),
624 ),
628 ),
632 ),
636 ),
640 ),
644 ),
648 ),
652 ),
656 ),
660 ),
664 ),
668 ),
672 ),
676 ),
680 ),
684 ),
688 ),
692 ),
696 ),
700 ),
704 ),
708 ),
712 ),
716 ),
720 ),
724 ),
728 ),
732 ),
736 ),
740 ),
744 ),
748 ),
752 ),
756 ),
760 ),
764 ),
768 ),
772 ),
776 ),
780 ),
784 ),
788 ),
792 ),
796 ),
800 ),
804 ),
808 ),
812 ),
816 ),
820 ),
821 'GETPIVOTDATA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
824 ),
828 ),
832 ),
836 ),
840 ),
844 ),
848 ),
852 ),
853 'HYPERLINK' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
857 ),
861 ),
865 ),
869 ),
873 ),
877 ),
881 ),
885 ),
889 ),
893 ),
897 ),
901 ),
905 ),
909 ),
913 ),
917 ),
921 ),
925 ),
929 ),
933 ),
937 ),
941 ),
946 ),
950 ),
954 ),
958 ),
962 ),
966 ),
970 ),
974 ),
978 ),
982 ),
986 ),
990 ),
994 ),
998 ),
1002 ),
1006 ),
1010 ),
1014 ),
1018 ),
1022 ),
1026 ),
1030 ),
1034 ),
1038 ),
1042 ),
1046 ),
1050 ),
1054 ),
1058 ),
1062 ),
1066 ),
1070 ),
1074 ),
1078 ),
1082 ),
1086 ),
1090 ),
1094 ),
1098 ),
1102 ),
1106 ),
1110 ),
1114 ),
1118 ),
1122 ),
1126 ),
1130 ),
1134 ),
1138 ),
1142 ),
1146 ),
1150 ),
1154 ),
1158 ),
1162 ),
1166 ),
1170 ),
1174 ),
1178 ),
1182 ),
1186 ),
1190 ),
1194 ),
1198 ),
1202 ),
1206 ),
1210 ),
1214 ),
1218 ),
1222 ),
1226 ),
1230 ),
1234 ),
1238 ),
1242 ),
1246 ),
1250 ),
1254 ),
1258 ),
1264 ),
1268 ),
1272 ),
1276 ),
1280 ),
1284 ),
1288 ),
1292 ),
1296 ),
1300 ),
1304 ),
1308 ),
1312 ),
1316 ),
1320 ),
1324 ),
1328 ),
1332 ),
1336 ),
1340 ),
1344 ),
1348 ),
1352 ),
1356 ),
1360 ),
1364 ),
1368 ),
1372 ),
1376 ),
1380 ),
1384 ),
1388 ),
1392 ),
1396 ),
1400 ),
1404 ),
1409 ),
1413 ),
1417 ),
1421 ),
1425 ),
1429 ),
1433 ),
1437 ),
1441 ),
1445 ),
1449 ),
1453 ),
1457 ),
1461 ),
1465 ),
1469 ),
1473 ),
1477 ),
1481 ),
1485 ),
1489 ),
1493 ),
1497 ),
1501 ),
1505 ),
1509 ),
1513 ),
1517 ),
1521 ),
1525 ),
1529 ),
1533 ),
1537 ),
1541 ),
1545 ),
1549 ),
1553 ),
1557 ),
1561 ),
1565 ),
1569 ),
1573 ),
1577 ),
1581 ),
1585 ),
1589 ),
1590 'TRANSPOSE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1593 ),
1597 ),
1601 ),
1605 ),
1609 ),
1613 ),
1617 ),
1621 ),
1625 ),
1629 ),
1633 ),
1637 ),
1641 ),
1645 ),
1649 ),
1653 ),
1657 ),
1661 ),
1665 ),
1669 ),
1673 ),
1677 ),
1681 ),
1685 ),
1689 ),
1693 ),
1697 ),
1701 ),
1705 ),
1709 )
1710 );
1713 // Internal functions used for special control purposes
1717 )
1718 );
1728 }
1733 }
1744 }
1745 }
1753 }
1754 }
1755 }
1757 /**
1758 * Get an instance of this class
1759 *
1760 * @access public
1761 * @param PHPExcel $workbook Injected workbook for working with a PHPExcel object,
1762 * or NULL to create a standalone claculation engine
1763 * @return PHPExcel_Calculation
1764 */
1769 }
1771 }
1775 }
1780 /**
1781 * Unset an instance of this class
1782 *
1783 * @access public
1784 * @param PHPExcel $workbook Injected workbook identifying the instance to unset
1785 */
1790 }
1791 }
1792 }
1794 /**
1795 * Flush the calculation cache for any existing instance of this class
1796 * but only if a PHPExcel_Calculation instance exists
1797 *
1798 * @access public
1799 * @return null
1800 */
1806 /**
1807 * Get the debuglog for this claculation engine instance
1808 *
1809 * @access public
1810 * @return PHPExcel_CalcEngine_Logger
1811 */
1814 }
1816 /**
1817 * __clone implementation. Cloning should not be allowed in a Singleton!
1818 *
1819 * @access public
1820 * @throws PHPExcel_Calculation_Exception
1821 */
1827 /**
1828 * Return the locale-specific translation of TRUE
1829 *
1830 * @access public
1831 * @return string locale-specific translation of TRUE
1832 */
1835 }
1837 /**
1838 * Return the locale-specific translation of FALSE
1839 *
1840 * @access public
1841 * @return string locale-specific translation of FALSE
1842 */
1845 }
1847 /**
1848 * Set the Array Return Type (Array or Value of first element in the array)
1849 *
1850 * @access public
1851 * @param string $returnType Array return type
1852 * @return boolean Success or failure
1853 */
1860 }
1865 /**
1866 * Return the Array Return Type (Array or Value of first element in the array)
1867 *
1868 * @access public
1869 * @return string $returnType Array return type
1870 */
1876 /**
1877 * Is calculation caching enabled?
1878 *
1879 * @access public
1880 * @return boolean
1881 */
1886 /**
1887 * Enable/disable calculation cache
1888 *
1889 * @access public
1890 * @param boolean $pValue
1891 */
1898 /**
1899 * Enable calculation cache
1900 */
1906 /**
1907 * Disable calculation cache
1908 */
1914 /**
1915 * Clear calculation cache
1916 */
1921 /**
1922 * Clear calculation cache for a specified worksheet
1923 *
1924 * @param string $worksheetName
1925 */
1929 }
1932 /**
1933 * Rename calculation cache for a specified worksheet
1934 *
1935 * @param string $fromWorksheetName
1936 * @param string $toWorksheetName
1937 */
1942 }
1946 /**
1947 * Get the currently defined locale code
1948 *
1949 * @return string
1950 */
1956 /**
1957 * Set the locale code
1958 *
1959 * @param string $locale The locale to use for formula translation
1960 * @return boolean
1961 */
1963 // Identify our locale and language
1967 }
1972 // Test whether we have any language data for this language (any locale)
1974 // initialise language/locale settings
1978 // Default is English, if user isn't requesting english, then read the necessary data from the locale files
1980 // Search for a file with a list of function names for locale
1981 $functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'functions';
1983 // If there isn't a locale specific function file, look for a language specific function file
1984 $functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'functions';
1987 }
1988 }
1989 // Retrieve the list of locale or language specific function names
1999 }
2000 }
2001 }
2002 // Default the TRUE and FALSE constants to the locale names of the TRUE() and FALSE() functions
2003 if (isset(self::$_localeFunctions['TRUE'])) { self::$_localeBoolean['TRUE'] = self::$_localeFunctions['TRUE']; }
2004 if (isset(self::$_localeFunctions['FALSE'])) { self::$_localeBoolean['FALSE'] = self::$_localeFunctions['FALSE']; }
2006 $configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'config';
2008 $configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'config';
2009 }
2021 }
2022 }
2023 }
2024 }
2025 }
2031 }
2049 }
2050 }
2051 }
2053 }
2056 // Convert any Excel function names to the required language
2059 // If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
2061 // So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
2062 // the formula
2066 // Only count/replace in alternating array entries
2070 }
2071 }
2073 // Then rebuild the formula string
2076 // If there's no quoted strings, then we do a simple count/replace
2079 }
2080 }
2083 }
2092 self::$functionReplaceFromExcel[] = '/(@?[^\w\.])'.preg_quote($excelFunctionName).'([\s]*\()/Ui';
2093 }
2096 }
2098 }
2104 }
2107 }
2108 }
2110 return self::_translateFormula(self::$functionReplaceFromExcel,self::$functionReplaceToLocale,$formula,',',self::$_localeArgumentSeparator);
2121 self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($localeFunctionName).'([\s]*\()/Ui';
2122 }
2125 }
2126 }
2132 }
2135 }
2136 }
2138 return self::_translateFormula(self::$functionReplaceFromLocale,self::$functionReplaceToExcel,$formula,self::$_localeArgumentSeparator,',');
2149 }
2150 }
2152 }
2157 /**
2158 * Wrap string values in quotes
2159 *
2160 * @param mixed $value
2161 * @return mixed
2162 */
2165 // Error values cannot be "wrapped"
2167 // Return Excel errors "as is"
2169 }
2170 // Return strings wrapped in quotes
2172 // Convert numeric errors to NaN error
2175 }
2181 /**
2182 * Remove quotes used as a wrapper to identify string values
2183 *
2184 * @param mixed $value
2185 * @return mixed
2186 */
2191 }
2192 // Convert numeric errors to NaN error
2195 }
2202 /**
2203 * Calculate cell value (using formula from a cell ID)
2204 * Retained for backward compatibility
2205 *
2206 * @access public
2207 * @param PHPExcel_Cell $pCell Cell to calculate
2208 * @return mixed
2209 * @throws PHPExcel_Calculation_Exception
2210 */
2216 }
2220 /**
2221 * Calculate the value of a cell formula
2222 *
2223 * @access public
2224 * @param PHPExcel_Cell $pCell Cell to calculate
2225 * @param Boolean $resetLog Flag indicating whether the debug log should be reset or not
2226 * @return mixed
2227 * @throws PHPExcel_Calculation_Exception
2228 */
2232 }
2236 // Initialise the logging settings if requested
2243 }
2245 // Execute the calculation for the cell formula
2249 );
2251 $result = self::_unwrapResult($this->_calculateFormulaValue($pCell->getValue(), $pCell->getCoordinate(), $pCell));
2258 }
2265 }
2266 // If there's only a single cell in the array, then we allow it
2268 // If keys are numeric, then it's a matrix result rather than a cell range result, so we permit it
2277 }
2278 }
2279 }
2281 }
2289 }
2294 /**
2295 * Validate and parse a formula string
2296 *
2297 * @param string $formula Formula to parse
2298 * @return array
2299 * @throws PHPExcel_Calculation_Exception
2300 */
2302 // Basic validation that this is indeed a formula
2303 // We return an empty array if not
2309 // Parse the formula and return the token stack
2314 /**
2315 * Calculate the value of a formula
2316 *
2317 * @param string $formula Formula to parse
2318 * @param string $cellID Address of the cell to calculate
2319 * @param PHPExcel_Cell $pCell Cell to calculate
2320 * @return mixed
2321 * @throws PHPExcel_Calculation_Exception
2322 */
2324 // Initialise the logging settings
2329 // Disable calculation cacheing because it only applies to cell calculations, not straight formulae
2330 // But don't actually flush any cache
2333 // Execute the calculation
2338 }
2340 // Reset calculation cacheing to its previous state
2348 // Is calculation cacheing enabled?
2349 // Is the value present in calculation cache?
2353 // Return the cached result
2356 }
2358 }
2363 }
2364 }
2366 /**
2367 * Parse a cell formula and calculate its value
2368 *
2369 * @param string $formula The formula to parse and calculate
2370 * @param string $cellID The ID (e.g. A3) of the cell that we are calculating
2371 * @param PHPExcel_Cell $pCell Cell to calculate
2372 * @return mixed
2373 * @throws PHPExcel_Calculation_Exception
2374 */
2378 // Basic validation that this is indeed a formula
2379 // We simply return the cell value if not
2391 }
2402 }
2406 }
2408 }
2409 }
2411 // Parse the formula onto the token stack and calculate the value
2413 $cellValue = $this->_processTokenStack($this->_parseFormula($formula, $pCell), $cellID, $pCell);
2416 // Save to calculation cache
2419 }
2421 // Return the calculated value
2426 /**
2427 * Ensure that paired matrix operands are both matrices and of the same size
2428 *
2429 * @param mixed &$operand1 First matrix operand
2430 * @param mixed &$operand2 Second matrix operand
2431 * @param integer $resize Flag indicating whether the matrices should be resized to match
2432 * and (if so), whether the smaller dimension should grow or the
2433 * larger should shrink.
2434 * 0 = no resize
2435 * 1 = shrink to fit
2436 * 2 = extend to fit
2437 */
2439 // Examine each of the two operands, and turn them into an array if they aren't one already
2440 // Note that this function should only be called if one or both of the operand is already an array
2449 }
2455 }
2458 // Given two matrices of (potentially) unequal size, convert the smaller in each dimension to match the larger
2459 self::_resizeMatricesExtend($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
2461 // Given two matrices of (potentially) unequal size, convert the larger in each dimension to match the smaller
2462 self::_resizeMatricesShrink($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
2463 }
2468 /**
2469 * Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0
2470 *
2471 * @param mixed &$matrix matrix operand
2472 * @return array An array comprising the number of rows, and number of columns
2473 */
2483 }
2484 }
2490 /**
2491 * Ensure that paired matrix operands are both matrices of the same size
2492 *
2493 * @param mixed &$matrix1 First matrix operand
2494 * @param mixed &$matrix2 Second matrix operand
2495 * @param integer $matrix1Rows Row size of first matrix operand
2496 * @param integer $matrix1Columns Column size of first matrix operand
2497 * @param integer $matrix2Rows Row size of second matrix operand
2498 * @param integer $matrix2Columns Column size of second matrix operand
2499 */
2500 private static function _resizeMatricesShrink(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
2505 }
2506 }
2511 }
2512 }
2513 }
2514 }
2520 }
2521 }
2526 }
2527 }
2528 }
2529 }
2533 /**
2534 * Ensure that paired matrix operands are both matrices of the same size
2535 *
2536 * @param mixed &$matrix1 First matrix operand
2537 * @param mixed &$matrix2 Second matrix operand
2538 * @param integer $matrix1Rows Row size of first matrix operand
2539 * @param integer $matrix1Columns Column size of first matrix operand
2540 * @param integer $matrix2Rows Row size of second matrix operand
2541 * @param integer $matrix2Columns Column size of second matrix operand
2542 */
2543 private static function _resizeMatricesExtend(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
2550 }
2551 }
2552 }
2557 }
2558 }
2559 }
2567 }
2568 }
2569 }
2574 }
2575 }
2576 }
2580 /**
2581 * Format details of an operand for display in the log (based on operand type)
2582 *
2583 * @param mixed $value First matrix operand
2584 * @return mixed
2585 */
2591 }
2602 }
2603 }
2609 }
2610 }
2615 /**
2616 * Format type and details of an operand for display in the log (based on operand type)
2617 *
2618 * @param mixed $value First matrix operand
2619 * @return mixed
2620 */
2626 }
2645 }
2646 }
2648 }
2656 // Convert any Excel matrix references to the MKMATRIX() function
2658 // If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
2660 // So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
2661 // the formula
2663 // Open and Closed counts used for trapping mismatched braces in the formula
2667 // Only count/replace in alternating array entries
2672 }
2673 }
2675 // Then rebuild the formula string
2678 // If there's no quoted strings, then we do a simple count/replace
2682 }
2683 // Trap for mismatched braces and trigger an appropriate error
2689 }
2695 }
2696 }
2697 }
2708 // Binary Operators
2709 // These operators always work on two values
2710 // Array key is the operator, the value indicates whether this is a left or right associative operator
2718 );
2720 // Comparison (Boolean) Operators
2721 // These operators work on two values, but always return a boolean result
2722 private static $_comparisonOperators = array('>' => TRUE, '<' => TRUE, '=' => TRUE, '>=' => TRUE, '<=' => TRUE, '<>' => TRUE);
2724 // Operator Precedence
2725 // This list includes all valid operators, whether binary (including boolean) or unary (such as %)
2726 // Array key is the operator, the value is its precedence
2737 );
2739 // Convert infix to postfix notation
2743 }
2745 // If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent worksheet),
2746 // so we store the parent worksheet so that we can re-attach it when necessary
2758 // Start with initialisation
2762 $expectingOperator = FALSE; // We use this test in syntax-checking the expression to determine when a
2763 // - is a negation or + is a positive operator rather than an operation
2764 $expectingOperand = FALSE; // We use this test in syntax-checking the expression to determine whether an operand
2765 // should be null in a function call
2766 // The guts of the lexical parser
2767 // Loop through the formula extracting each operator and operand in turn
2769 //echo 'Assessing Expression '.substr($formula, $index),PHP_EOL;
2770 $opCharacter = $formula{$index}; // Get the first character of the value at the current index position
2771 //echo 'Initial character of expression block is '.$opCharacter,PHP_EOL;
2772 if ((isset(self::$_comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset(self::$_comparisonOperators[$formula{$index+1}]))) {
2774 //echo 'Initial character of expression block is comparison operator '.$opCharacter.PHP_EOL;
2775 }
2777 // Find out if we're currently at the beginning of a number, variable, cell reference, function, parenthesis or operand
2779 //echo '$isOperandOrFunction is '.(($isOperandOrFunction) ? 'True' : 'False').PHP_EOL;
2780 //var_dump($match);
2783 //echo 'Element is a Negation operator',PHP_EOL;
2787 //echo 'Element is a Percentage operator',PHP_EOL;
2790 } elseif ($opCharacter == '+' && !$expectingOperator) { // Positive (unary plus rather than binary operator plus) can be discarded?
2791 //echo 'Element is a Positive number, not Plus operator',PHP_EOL;
2793 } elseif ((($opCharacter == '~') || ($opCharacter == '|')) && (!$isOperandOrFunction)) { // We have to explicitly deny a tilde or pipe, because they are legal
2794 return $this->_raiseFormulaError("Formula Error: Illegal character '~'"); // on the stack but not in the input expression
2796 } elseif ((isset(self::$_operators[$opCharacter]) or $isOperandOrFunction) && $expectingOperator) { // Are we putting an operator on the stack?
2797 //echo 'Element with value '.$opCharacter.' is an Operator',PHP_EOL;
2801 @(self::$_operatorAssociativity[$opCharacter] ? self::$_operatorPrecedence[$opCharacter] < self::$_operatorPrecedence[$o2['value']] : self::$_operatorPrecedence[$opCharacter] <= self::$_operatorPrecedence[$o2['value']])) {
2802 $output[] = $stack->pop(); // Swap operands and higher precedence operators from the stack to the output
2803 }
2804 $stack->push('Binary Operator',$opCharacter); // Finally put our current operator onto the stack
2808 } elseif ($opCharacter == ')' && $expectingOperator) { // Are we expecting to close a parenthesis?
2809 //echo 'Element is a Closing bracket',PHP_EOL;
2812 if ($o2 === NULL) return $this->_raiseFormulaError('Formula Error: Unexpected closing brace ")"');
2814 }
2816 if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches)) { // Did this parenthesis just close a function?
2818 //echo 'Closed Function is '.$functionName,PHP_EOL;
2820 $argumentCount = $d['value']; // See how many arguments there were (argument count is the next value stored on the stack)
2821 //if ($argumentCount == 0) {
2822 // echo 'With no arguments',PHP_EOL;
2823 //} elseif ($argumentCount == 1) {
2824 // echo 'With 1 argument',PHP_EOL;
2825 //} else {
2826 // echo 'With '.$argumentCount.' arguments',PHP_EOL;
2827 //}
2831 //echo 'Built-in function '.$functionName,PHP_EOL;
2835 //echo 'PHPExcel function '.$functionName,PHP_EOL;
2840 }
2841 // Check the argument count
2845 //echo '$expectedArgumentCount is between 0 and '.abs($expectedArgumentCount),PHP_EOL;
2849 }
2851 //echo '$expectedArgumentCount is numeric '.$expectedArgumentCount,PHP_EOL;
2855 }
2856 }
2859 //print_r($argMatch);
2860 //echo PHP_EOL;
2866 }
2872 }
2878 }
2880 }
2881 }
2883 return $this->_raiseFormulaError("Formula Error: Wrong number of arguments for $functionName() function: $argumentCount given, ".$expectedArgumentCountString." expected");
2884 }
2885 }
2889 //echo 'Element is a Function argument separator',PHP_EOL;
2893 }
2894 // If we've a comma when we're expecting an operand, then what we actually have is a null operand;
2895 // so push a null onto the stack
2897 $output[] = array('type' => 'NULL Value', 'value' => self::$_ExcelConstants['NULL'], 'reference' => NULL);
2898 }
2899 // make sure there was a function
2911 // echo 'Element is an Opening Bracket<br />';
2915 } elseif ($isOperandOrFunction && !$expectingOperator) { // do we now have a function/variable/number?
2920 // echo 'Element with value '.$val.' is an Operand, Variable, Constant, String, Number, Cell Reference or Function<br />';
2924 // echo 'Element '.$val.' is a Function<br />';
2925 if (isset(self::$_PHPExcelFunctions[strtoupper($matches[1])]) || isset(self::$_controlFunctions[strtoupper($matches[1])])) { // it's a function
2934 }
2938 }
2940 // echo 'Element '.$val.' is a Cell reference<br />';
2941 // Watch for this case-change when modifying to allow cell references in different worksheets...
2942 // Should only be applied to the actual cell column, not the worksheet name
2944 // If the last entry on the stack was a : operator, then we have a cell range reference
2947 // If we have a worksheet reference, then we're playing with a 3D reference
2949 // Otherwise, we 'inherit' the worksheet reference from the start cell reference
2950 // The start of the cell range reference should be the last entry in $output
2955 }
2958 }
2959 }
2962 // $expectingOperator = FALSE;
2964 // echo 'Element is a Variable, Constant, String, Number or Boolean<br />';
2965 // If the last entry on the stack was a : operator, then we may have a row or column range reference
2972 }
2977 }
2981 // Row range
2982 $endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestColumn() : 'XFD'; // Max 16,384 columns for Excel2007
2987 // Column range
2988 $endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestRow() : 1048576; // Max 1,048,576 rows for Excel2007
2991 }
2992 }
2996 // echo 'Element is a String<br />';
2997 // UnEscape any quotes within the string
3000 // echo 'Element is a Number<br />';
3001 if ((strpos($val,'.') !== FALSE) || (stripos($val,'e') !== FALSE) || ($val > PHP_INT_MAX) || ($val < -PHP_INT_MAX)) {
3002 // echo 'Casting '.$val.' to float<br />';
3005 // echo 'Casting '.$val.' to integer<br />';
3007 }
3010 // echo 'Element '.$excelConstant.' is an Excel Constant<br />';
3012 } elseif (($localeConstant = array_search(trim(strtoupper($val)), self::$_localeBoolean)) !== FALSE) {
3013 // echo 'Element '.$localeConstant.' is an Excel Constant<br />';
3015 }
3019 }
3026 $output[] = array('type' => 'NULL Value', 'value' => self::$_ExcelConstants['NULL'], 'reference' => NULL);
3031 }
3036 }
3037 // Test for end of formula string
3039 // Did we end with an operator?.
3040 // Only valid for the % unary operator
3045 }
3046 }
3047 // Ignore white space
3050 }
3054 }
3055 // If we're expecting an operator, but only have a space between the previous and next operands (and both are
3056 // Cell References) then we have an INTERSECTION operator
3057 // echo 'Possible Intersect Operator<br />';
3058 if (($expectingOperator) && (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'.*/Ui', substr($formula, $index), $match)) &&
3060 // echo 'Element is an Intersect Operator<br />';
3064 @(self::$_operatorAssociativity[$opCharacter] ? self::$_operatorPrecedence[$opCharacter] < self::$_operatorPrecedence[$o2['value']] : self::$_operatorPrecedence[$opCharacter] <= self::$_operatorPrecedence[$o2['value']])) {
3065 $output[] = $stack->pop(); // Swap operands and higher precedence operators from the stack to the output
3066 }
3069 }
3070 }
3071 }
3075 return $this->_raiseFormulaError("Formula Error: Expecting ')'"); // if there are any opening braces on the stack, then braces were unbalanced
3077 }
3083 {
3092 }
3093 }
3095 }
3097 // evaluate postfix notation
3101 // If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent cell collection),
3102 // so we store the parent cell collection so that we can re-attach it when necessary
3107 // Loop through each token in turn
3109 // print_r($tokenData);
3110 // echo '<br />';
3112 // echo '<b>Token is '.$token.'</b><br />';
3113 // 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
3115 // echo 'Token is a binary operator<br />';
3116 // We must have two operands, error if we don't
3117 if (($operand2Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
3118 if (($operand1Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
3123 // Log what we're doing
3125 $this->_debugLog->writeDebugLog('Evaluating Range ', $this->_showValue($operand1Data['reference']), ' ', $token, ' ', $this->_showValue($operand2Data['reference']));
3127 $this->_debugLog->writeDebugLog('Evaluating ', $this->_showValue($operand1), ' ', $token, ' ', $this->_showValue($operand2));
3128 }
3130 // Process the operation in the appropriate manner
3132 // Comparison (Boolean) Operators
3141 // Binary Operators
3148 }
3153 }
3162 }
3163 }
3171 }
3172 }
3174 $oData = array_merge(explode(':',$operand1Data['reference']),explode(':',$operand2Data['reference']));
3180 }
3181 $cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);
3183 $cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($sheet1), FALSE);
3186 }
3190 }
3197 $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'minusEquals',$stack);
3200 $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayTimesEquals',$stack);
3203 $this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayRightDivide',$stack);
3209 // If either of the operands is a matrix, we need to treat them both as matrices
3210 // (converting the other operand to a matrix if need be); then perform the required
3211 // matrix operation
3214 }
3217 }
3219 // Ensure that both operands are arrays/matrices
3222 // Convert operand 1 from a PHP array to a matrix
3224 // Perform the required operation against the operand 1 matrix, passing in operand 2
3230 }
3232 $result = '"'.str_replace('""','"',self::_unwrapResult($operand1,'"').self::_unwrapResult($operand2,'"')).'"';
3233 }
3245 }
3246 }
3247 $cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);
3248 $this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($cellIntersect));
3251 }
3253 // if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
3255 // echo 'Token is a unary operator<br />';
3256 if (($arg = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
3259 // echo 'Token is a negation operator<br />';
3263 // echo 'Token is a percentile operator<br />';
3266 }
3276 }
3281 }
3285 // echo 'Element '.$token.' is a Cell reference<br />';
3287 // echo 'Reference is a Range of cells<br />';
3289 // We can't access the range, so return a REF error
3296 // It's a Reference to an external workbook (not currently supported)
3298 }
3300 // echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';
3301 $this->_debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in worksheet ', $matches[2]);
3303 $cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($matches[2]), FALSE);
3306 }
3307 $this->_debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->_showTypeDetails($cellValue));
3308 // $cellRef = $matches[2].'!'.$cellRef;
3310 // echo '$cellRef='.$cellRef.' in current worksheet<br />';
3316 }
3317 $this->_debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' is ', $this->_showTypeDetails($cellValue));
3318 }
3319 }
3321 // echo 'Reference is a single Cell<br />';
3323 // We can't access the cell, so return a REF error
3330 // It's a Reference to an external workbook (not currently supported)
3332 }
3333 // echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';
3338 $cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($matches[2]), FALSE);
3342 }
3345 }
3346 $this->_debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->_showTypeDetails($cellValue));
3347 // $cellRef = $matches[2].'!'.$cellRef;
3349 // echo '$cellRef='.$cellRef.' in current worksheet<br />';
3356 }
3357 $this->_debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' is ', $this->_showTypeDetails($cellValue));
3358 }
3359 }
3360 }
3363 // if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
3365 // echo 'Token is a function<br />';
3370 $this->_debugLog->writeDebugLog('Evaluating Function ', self::_localeFunc($functionName), '() with ', (($argCount == 0) ? 'no' : $argCount), ' argument', (($argCount == 1) ? '' : 's'));
3371 }
3372 if ((isset(self::$_PHPExcelFunctions[$functionName])) || (isset(self::$_controlFunctions[$functionName]))) { // function
3381 }
3382 // get the arguments for this function
3383 // echo 'Function '.$functionName.' expects '.$argCount.' arguments<br />';
3397 }
3401 }
3402 }
3403 // Reverse the order of the arguments
3408 }
3409 // echo 'Arguments are: ';
3410 // print_r($args);
3411 // echo '<br />';
3415 $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', implode(self::$_localeArgumentSeparator.' ',PHPExcel_Calculation_Functions::flattenArray($argArrayVals)), ' )');
3416 }
3417 }
3418 // Process each argument in turn, building the return value as an array
3419 // if (($argCount == 1) && (is_array($args[1])) && ($functionName != 'MKMATRIX')) {
3420 // $operand1 = $args[1];
3421 // $this->_debugLog->writeDebugLog('Argument is a matrix: ', $this->_showValue($operand1));
3422 // $result = array();
3423 // $row = 0;
3424 // foreach($operand1 as $args) {
3425 // if (is_array($args)) {
3426 // foreach($args as $arg) {
3427 // $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($arg), ' )');
3428 // $r = call_user_func_array($functionCall,$arg);
3429 // $this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));
3430 // $result[$row][] = $r;
3431 // }
3432 // ++$row;
3433 // } else {
3434 // $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($args), ' )');
3435 // $r = call_user_func_array($functionCall,$args);
3436 // $this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));
3437 // $result[] = $r;
3438 // }
3439 // }
3440 // } else {
3441 // Process the argument with the appropriate function call
3444 }
3450 }
3453 }
3454 // }
3456 $this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($result));
3457 }
3459 }
3462 // if the token is a number, boolean, string or an Excel error, push it onto the stack
3465 // echo 'Token is a PHPExcel constant: '.$excelConstant.'<br />';
3467 $this->_debugLog->writeDebugLog('Evaluating Constant ', $excelConstant, ' as ', $this->_showTypeDetails(self::$_ExcelConstants[$excelConstant]));
3468 } elseif ((is_numeric($token)) || ($token === NULL) || (is_bool($token)) || ($token == '') || ($token{0} == '"') || ($token{0} == '#')) {
3469 // echo 'Token is a number, boolean, string, null or an Excel error<br />';
3471 // if the token is a named range, push the named range name onto the stack
3473 // echo 'Token is a named range<br />';
3475 // echo 'Named Range is '.$namedRange.'<br />';
3477 $cellValue = $this->extractNamedRange($namedRange, ((NULL !== $pCell) ? $pCellWorksheet : NULL), FALSE);
3479 $this->_debugLog->writeDebugLog('Evaluation Result for named range ', $namedRange, ' is ', $this->_showTypeDetails($cellValue));
3483 }
3484 }
3485 }
3486 // when we're out of tokens, the stack should have a single element, the final result
3491 // if ((is_array($output)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {
3492 // return array_shift(PHPExcel_Calculation_Functions::flattenArray($output));
3493 // }
3504 }
3505 }
3506 // Numbers, matrices and booleans can pass straight through, as they're already valid
3508 // We only need special validations for the operand if it is a string
3509 // Start by stripping off the quotation marks we use to identify true excel string values internally
3511 // If the string is a numeric value, we treat it as a numeric, so no further testing
3513 // If not a numeric, test to see if the value is an Excel error, and so can't be used in normal binary operations
3519 // If not a numeric or a fraction, then it's a text string, and so can't be used in mathematical binary operations
3521 $this->_debugLog->writeDebugLog('Evaluation Result is a ', $this->_showTypeDetails('#VALUE!'));
3523 }
3524 }
3525 }
3527 // return a true if the value of the operand is one that we can use in normal binary operations
3532 private function _executeBinaryComparisonOperation($cellID, $operand1, $operand2, $operation, &$stack, $recursingArrays=FALSE) {
3533 // If we're dealing with matrix operations, we want a matrix result
3538 $this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operandData), ' ', $operation, ' ', $this->_showValue($operand2));
3542 }
3545 $this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operand1), ' ', $operation, ' ', $this->_showValue($operandData));
3549 }
3553 $this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operandData), ' ', $operation, ' ', $this->_showValue($operand2[$x]));
3554 $this->_executeBinaryComparisonOperation($cellID,$operandData,$operand2[$x],$operation,$stack,TRUE);
3557 }
3558 }
3559 // Log the result details
3560 $this->_debugLog->writeDebugLog('Comparison Evaluation Result is ', $this->_showTypeDetails($result));
3561 // And push the result onto the stack
3564 }
3566 // Simple validate the two operands if they are string values
3567 if (is_string($operand1) && $operand1 > '' && $operand1{0} == '"') { $operand1 = self::_unwrapResult($operand1); }
3568 if (is_string($operand2) && $operand2 > '' && $operand2{0} == '"') { $operand2 = self::_unwrapResult($operand2); }
3570 // Use case insensitive comparaison if not OpenOffice mode
3571 if (PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE)
3572 {
3575 }
3579 }
3580 }
3582 $useLowercaseFirstComparison = is_string($operand1) && is_string($operand2) && PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE;
3584 // execute the necessary operation
3586 // Greater than
3592 }
3594 // Less than
3600 }
3602 // Equality
3608 }
3610 // Greater than or equal
3618 }
3620 // Less than or equal
3628 }
3630 // Inequality
3636 }
3638 }
3640 // Log the result details
3642 // And push the result onto the stack
3645 }
3647 /**
3648 * Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters
3649 * @param string $str1 First string value for the comparison
3650 * @param string $str2 Second string value for the comparison
3651 * @return integer
3652 */
3654 {
3659 }
3661 private function _executeNumericBinaryOperation($cellID,$operand1,$operand2,$operation,$matrixFunction,&$stack) {
3662 // Validate the two operands
3666 // If either of the operands is a matrix, we need to treat them both as matrices
3667 // (converting the other operand to a matrix if need be); then perform the required
3668 // matrix operation
3670 // Ensure that both operands are arrays/matrices of the same size
3674 // Convert operand 1 from a PHP array to a matrix
3676 // Perform the required operation against the operand 1 matrix, passing in operand 2
3682 }
3684 if ((PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) &&
3689 // If we're dealing with non-matrix operations, execute the necessary operation
3691 // Addition
3695 // Subtraction
3699 // Multiplication
3703 // Division
3706 // Trap for Divide by Zero error
3712 }
3714 // Power
3718 }
3719 }
3720 }
3722 // Log the result details
3724 // And push the result onto the stack
3730 // trigger an error, but nicely, if need be
3739 /**
3740 * Extract range values
3741 *
3742 * @param string &$pRange String based range representation
3743 * @param PHPExcel_Worksheet $pSheet Worksheet
3744 * @param boolean $resetLog Flag indicating whether calculation log should be reset or not
3745 * @return mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.
3746 * @throws PHPExcel_Calculation_Exception
3747 */
3748 public function extractCellRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = NULL, $resetLog = TRUE) {
3749 // Return value
3752 // echo 'extractCellRange('.$pRange.')',PHP_EOL;
3755 // echo 'Passed sheet name is '.$pSheetName.PHP_EOL;
3756 // echo 'Range reference is '.$pRange.PHP_EOL;
3758 // echo '$pRange reference includes sheet reference',PHP_EOL;
3760 // echo 'New sheet name is '.$pSheetName,PHP_EOL;
3761 // echo 'Adjusted Range reference is '.$pRange,PHP_EOL;
3763 }
3765 // Extract range
3769 // Single cell in range
3773 $returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
3776 }
3778 // Extract cell data for all cells in the range
3780 // Extract range
3784 $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
3787 }
3788 }
3789 }
3790 }
3792 // Return
3797 /**
3798 * Extract range values
3799 *
3800 * @param string &$pRange String based range representation
3801 * @param PHPExcel_Worksheet $pSheet Worksheet
3802 * @return mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.
3803 * @param boolean $resetLog Flag indicating whether calculation log should be reset or not
3804 * @throws PHPExcel_Calculation_Exception
3805 */
3806 public function extractNamedRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = NULL, $resetLog = TRUE) {
3807 // Return value
3810 // echo 'extractNamedRange('.$pRange.')<br />';
3813 // echo 'Current sheet name is '.$pSheetName.'<br />';
3814 // echo 'Range reference is '.$pRange.'<br />';
3816 // echo '$pRange reference includes sheet reference',PHP_EOL;
3818 // echo 'New sheet name is '.$pSheetName,PHP_EOL;
3819 // echo 'Adjusted Range reference is '.$pRange,PHP_EOL;
3821 }
3823 // Named range?
3827 // echo 'Named Range '.$pRange.' (';
3830 // Convert row and column references
3832 $pRange = $splitRange[0][0] . '1:' . $splitRange[0][1] . $namedRange->getWorksheet()->getHighestRow();
3834 $pRange = 'A' . $splitRange[0][0] . ':' . $namedRange->getWorksheet()->getHighestColumn() . $splitRange[0][1];
3835 }
3836 // echo $pRange.') is in sheet '.$namedRange->getWorksheet()->getTitle().'<br />';
3838 // if ($pSheet->getTitle() != $namedRange->getWorksheet()->getTitle()) {
3839 // if (!$namedRange->getLocalOnly()) {
3840 // $pSheet = $namedRange->getWorksheet();
3841 // } else {
3842 // return $returnValue;
3843 // }
3844 // }
3847 }
3849 // Extract range
3851 // var_dump($aReferences);
3853 // Single cell (or single column or row) in range
3857 $returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
3860 }
3862 // Extract cell data for all cells in the range
3864 // Extract range
3866 // echo 'NAMED RANGE: $currentCol='.$currentCol.' $currentRow='.$currentRow.'<br />';
3869 $returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
3872 }
3873 }
3874 }
3875 // print_r($returnValue);
3876 // echo '<br />';
3877 }
3879 // Return
3884 /**
3885 * Is a specific function implemented?
3886 *
3887 * @param string $pFunction Function Name
3888 * @return boolean
3889 */
3893 return (self::$_PHPExcelFunctions[$pFunction]['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY');
3896 }
3900 /**
3901 * Get a list of all implemented functions as an array of function objects
3902 *
3903 * @return array of PHPExcel_Calculation_Function
3904 */
3906 // Return value
3908 // Loop functions
3914 );
3915 }
3916 }
3918 // Return
3923 /**
3924 * Get a list of all Excel function names
3925 *
3926 * @return array
3927 */
3932 /**
3933 * Get a list of implemented Excel function names
3934 *
3935 * @return array
3936 */
3938 // Return value
3940 // Loop functions
3944 }
3945 }
3947 // Return