| blob | 7349771e004d981588a19edc017708a5404f57b8 |
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
23 #include <editeng/langitem.hxx>
24 #include <editeng/justifyitem.hxx>
25 #include <formula/random.hxx>
26 #include <osl/thread.h>
27 #include <svx/algitem.hxx>
28 #include <unotools/textsearch.hxx>
29 #include <svl/zforlist.hxx>
30 #include <svl/zformat.hxx>
31 #include <tools/urlobj.hxx>
32 #include <unotools/charclass.hxx>
33 #include <sfx2/docfile.hxx>
34 #include <sfx2/printer.hxx>
35 #include <unotools/collatorwrapper.hxx>
36 #include <unotools/transliterationwrapper.hxx>
37 #include <rtl/ustring.hxx>
38 #include <unicode/uchar.h>
56 #include <basic/sbstar.hxx>
63 #include <comphelper/processfactory.hxx>
64 #include <comphelper/random.hxx>
65 #include <comphelper/string.hxx>
66 #include <svl/sharedstringpool.hxx>
68 #include <stdlib.h>
69 #include <string.h>
70 #include <math.h>
71 #include <vector>
72 #include <memory>
73 #include <limits>
88 {
93 {
95 {
99 else
100 {
101 FormulaTokenRef xNew;
103 // DoubleError handled by JumpMatrix
108 {
111 }
115 else
116 {
119 {
121 {
126 {
132 }
133 else
134 {
135 // Treat empty and empty path as 0, but string
136 // as error.
140 }
148 }
149 else
154 }
155 }
156 else
163 }
164 else
166 // or DoubleError
170 }
171 }
172 }
173 }
176 }
178 {
181 }
183 // set endpoint of path for main code line
185 }
186 }
189 {
195 }
196 else
201 }
202 }
203 else
208 }
209 else
214 }
215 }
216 }
217 }
218 }
220 /** Store a matrix value in another matrix in the context of that other matrix
221 is the result matrix of a jump matrix. All arguments must be valid and are
222 not checked. */
225 {
227 {
230 }
232 {
234 }
235 else
236 {
238 }
239 }
242 {
246 {
247 // Reset nGlobalError here to not propagate the old error, if any.
252 }
261 {
264 // Act on implicitly propagated error, if any.
276 {
277 ScAddress aAdr;
280 else
281 {
283 ScRefCellValue aCell;
288 }
289 }
293 {
296 // Handles also existing jump matrix case and sets error on
297 // elements.
301 }
304 {
307 {
310 }
311 // If the matrix has no queried error at all we can simply use
312 // it as result and don't need to bother with jump matrix.
318 {
321 }
323 {
325 {
328 {
332 }
333 }
334 }
338 FormulaTokenRef xNew;
341 {
343 }
344 else
345 {
348 // Init all jumps to no error to save single calls. Error
349 // is the exceptional condition.
352 // Up to first error position simply store results, no need
353 // to evaluate error conditions again.
356 {
358 {
360 }
363 }
364 // Now the mixed cases.
366 {
368 {
373 }
374 else
377 }
378 }
380 }
383 }
386 // set endpoint of path for main code line
389 }
391 }
394 {
395 // error, calculate 2nd argument
398 }
399 else
400 {
401 // no error, push 1st argument and continue
405 }
406 }
409 {
410 // We have to set a jump, if there was none chosen because of an error set
411 // it to endpoint.
417 {
419 {
423 else
424 {
425 FormulaTokenRef xNew;
427 // DoubleError handled by JumpMatrix
436 else
437 {
440 {
442 {
446 {
450 {
453 {
456 errIllegalArgument);
457 }
458 }
459 }
460 else
461 {
463 }
465 {
469 }
470 else
471 {
475 }
476 }
477 }
481 }
483 {
485 // set endpoint of path for main code line
488 }
489 }
490 }
493 {
496 {
499 }
500 else
502 }
503 }
506 }
509 {
517 {
519 {
522 }
524 {
527 }
528 else
529 {
532 }
534 }
535 }
538 {
543 {
546 else
547 {
549 }
552 {
555 }
556 else
557 {
560 {
562 {
565 {
568 }
570 }
573 {
576 {
580 }
581 else
583 }
586 {
587 ScAddress aAdr;
590 {
594 }
595 else
596 {
597 ScRefCellValue aCell;
602 {
605 {
607 nGlobalError);
609 }
611 }
612 else
613 {
617 {
621 }
622 else
624 }
625 }
626 }
631 ScRange aRange;
634 {
638 }
639 else
640 {
641 // Do not modify the original range because we use it
642 // to adjust the size of the result matrix if necessary.
650 {
653 }
654 else
655 {
656 // Replicate column and/or row of a vector if it is
657 // one. Note that this could be a range reference
658 // that in fact consists of only one cell, e.g. A1:A1
665 ScRefCellValue aCell;
670 {
673 {
675 nGlobalError);
677 }
679 }
680 else
681 {
685 {
689 }
690 else
692 }
693 }
697 }
698 }
705 {
709 }
711 {
714 }
715 else
716 {
721 {
724 }
725 else
726 {
728 }
730 }
731 }
734 {
739 }
742 {
746 }
747 }
748 }
749 }
752 {
759 {
760 // a false without path results in an empty path value
763 else
765 }
769 }
771 {
774 {
777 {
778 // This is not the current state of the interpreter, so
779 // push without error, and elements' errors are coded into
780 // double.
782 }
783 }
785 }
786 }
793 // Remove jump matrix from map and remember result matrix in case it
794 // could be reused in another path of the same condition.
796 {
800 }
802 }
804 }
807 {
812 {
816 {
832 {
833 ScAddress aAdr;
836 ScRefCellValue aCell;
841 {
846 }
847 else
848 {
851 }
852 }
855 {
858 {
861 }
866 {
869 }
873 {
876 }
877 else
878 {
881 }
882 }
885 // TODO: Find out how to handle this...
889 }
890 }
895 }
898 {
903 ScAddress aAdr;
905 {
909 {
924 {
926 ScRefCellValue aCell;
931 {
936 }
937 else
938 {
941 }
942 }
949 else
951 // errors are transported as DoubleError inside matrix
956 }
957 }
962 {
965 }
968 {
979 {
981 {
985 {
987 {
991 {
995 }
996 else
997 {
1001 }
1002 }
1004 }
1005 else
1007 }
1008 }
1011 {
1034 }
1035 }
1037 {
1051 }
1055 }
1058 {
1065 else
1071 {
1074 }
1077 }
1080 {
1082 {
1085 {
1088 }
1091 }
1092 else
1094 }
1097 {
1099 {
1102 {
1105 }
1108 }
1109 else
1111 }
1114 {
1116 {
1119 {
1122 }
1125 }
1126 else
1128 }
1131 {
1133 {
1136 {
1139 }
1142 }
1143 else
1145 }
1148 {
1150 {
1153 {
1156 }
1159 }
1160 else
1162 }
1165 {
1167 {
1170 {
1173 }
1176 }
1177 else
1179 }
1182 {
1186 {
1191 {
1193 {
1195 {
1205 {
1206 ScAddress aAdr;
1209 {
1210 ScRefCellValue aCell;
1213 {
1216 }
1217 // else: Xcl raises no error here
1218 }
1219 }
1223 {
1224 ScRange aRange;
1227 {
1232 {
1234 do
1235 {
1239 }
1241 }
1242 }
1247 {
1250 {
1255 {
1258 }
1259 else
1261 }
1262 // else: GetMatrix did set errIllegalParameter
1263 }
1268 }
1269 }
1270 else
1272 }
1275 else
1277 }
1278 }
1281 {
1285 {
1290 {
1292 {
1294 {
1304 {
1305 ScAddress aAdr;
1308 {
1309 ScRefCellValue aCell;
1312 {
1315 }
1316 // else: Xcl raises no error here
1317 }
1318 }
1322 {
1323 ScRange aRange;
1326 {
1331 {
1333 do
1334 {
1338 }
1340 }
1341 }
1346 {
1350 {
1355 {
1358 }
1359 else
1361 }
1362 // else: GetMatrix did set errIllegalParameter
1363 }
1368 }
1369 }
1370 else
1372 }
1375 else
1377 }
1378 }
1381 {
1386 {
1391 {
1393 {
1395 {
1405 {
1406 ScAddress aAdr;
1409 {
1410 ScRefCellValue aCell;
1413 {
1416 }
1417 /* TODO: set error? Excel doesn't have XOR, but
1418 * doesn't set an error in this case for AND and
1419 * OR. */
1420 }
1421 }
1425 {
1426 ScRange aRange;
1429 {
1434 {
1436 do
1437 {
1441 }
1443 }
1444 }
1449 {
1453 {
1458 {
1461 }
1462 else
1464 }
1465 // else: GetMatrix did set errIllegalParameter
1466 }
1471 }
1472 }
1473 else
1475 }
1478 else
1480 }
1481 }
1484 {
1485 // Simple negation doesn't change current format type to number, keep
1486 // current type.
1489 {
1491 {
1495 else
1496 {
1502 else
1503 {
1506 }
1507 }
1508 }
1512 }
1513 }
1516 {
1527 }
1530 {
1533 {
1535 {
1539 else
1540 {
1546 else
1547 {
1550 }
1551 }
1552 }
1556 }
1557 }
1560 {
1570 else
1572 }
1575 {
1585 else
1587 }
1590 {
1600 else
1602 }
1605 {
1614 else
1615 {
1621 else
1624 }
1625 }
1628 {
1637 else
1638 {
1644 else
1647 }
1648 }
1651 {
1653 }
1656 {
1658 }
1661 {
1664 }
1667 {
1670 }
1673 {
1675 }
1678 {
1680 }
1683 {
1685 }
1688 {
1690 }
1693 {
1695 }
1698 {
1700 }
1703 {
1705 }
1708 {
1710 }
1713 {
1715 }
1718 {
1720 }
1723 {
1725 }
1728 {
1730 }
1733 {
1735 }
1738 {
1740 }
1743 {
1745 }
1748 {
1752 else
1754 }
1757 {
1761 else
1763 }
1766 {
1770 else
1772 }
1775 {
1777 }
1780 {
1782 }
1785 {
1787 }
1790 {
1792 }
1795 {
1797 }
1800 {
1804 else
1806 }
1809 {
1813 {
1815 {
1819 }
1823 {
1824 ScAddress aAdr;
1827 // NOTE: this differs from COUNTBLANK() ScCountEmptyCells() that
1828 // may treat ="" in the referenced cell as blank for Excel
1829 // interoperability.
1830 ScRefCellValue aCell;
1834 }
1839 {
1845 else
1846 {
1852 // else: false, not empty (which is what Xcl does)
1853 }
1854 }
1858 }
1861 }
1864 {
1868 {
1875 {
1876 ScAddress aAdr;
1880 ScRefCellValue aCell;
1883 {
1885 {
1895 }
1896 }
1897 }
1900 {
1906 else
1907 {
1913 }
1914 }
1918 }
1921 }
1924 {
1926 }
1929 {
1931 }
1934 {
1937 {
1940 {
1941 ScAddress aAdr;
1945 ScRefCellValue aCell;
1948 {
1950 {
1953 }
1954 }
1955 }
1958 // TODO: we don't have type information for arrays except
1959 // numerical/string.
1960 // Fall through
1965 }
1969 }
1972 {
1975 {
1978 {
1979 ScAddress aAdr;
1983 ScRefCellValue aCell;
1986 {
1988 {
1989 // NOTE: this is Xcl nonsense!
1995 {
1999 else
2001 }
2008 }
2009 }
2010 else
2012 }
2017 {
2020 }
2021 else
2027 {
2030 }
2031 else
2033 // we could return the type of one element if in JumpMatrix or
2034 // ForceArray mode, but Xcl doesn't ...
2039 {
2042 }
2043 else
2045 }
2047 }
2050 {
2052 }
2055 {
2057 }
2062 {
2069 {
2075 {
2078 {
2098 }
2099 }
2100 }
2108 }
2110 }
2116 {
2120 {
2122 {
2125 {
2126 // Let's handle external reference separately...
2129 }
2131 ;
2132 }
2134 }
2138 else
2139 {
2140 ScRefCellValue aCell;
2145 // *** ADDRESS INFO ***
2149 }
2153 }
2157 }
2163 }
2167 OUString aFuncResult;
2169 {
2172 else
2173 {
2176 {
2177 OUStringBuffer aBuf;
2182 OUString aTabName;
2186 }
2187 }
2188 }
2190 }
2193 // Yes, passing tab as col is intentional!
2194 OUStringBuffer aFuncResult;
2195 OUString aCellStr =
2204 }
2206 // *** CELL PROPERTIES ***
2210 {
2214 }
2215 else
2217 }
2220 sal_Unicode c;
2223 else
2226 }
2235 // font color doesn't matter here
2243 }
2248 {
2252 {
2259 }
2260 }
2262 }
2268 }
2270 // *** FORMATTING ***
2273 OUString aFuncResult;
2277 }
2282 }
2287 }
2288 else
2290 }
2291 }
2292 }
2295 {
2296 sal_uInt16 nFileId;
2297 OUString aTabName;
2298 ScSingleRefData aRef;
2303 {
2306 }
2310 {
2313 }
2315 SCCOL nCol;
2316 SCROW nRow;
2317 SCTAB nTab;
2321 {
2324 }
2335 {
2336 // For SHEET, No idea what number we should set, but let's always set
2337 // 1 if the external sheet exists, no matter what sheet. Excel does
2338 // the same.
2341 else
2343 }
2345 {
2346 // ODF 1.2 says we need to always display address using the ODF A1 grammar.
2347 ScTokenArray aArray;
2351 OUString aStr;
2354 }
2356 {
2357 // 'file URI'#$SheetName
2361 {
2362 // In theory this should never happen...
2365 }
2367 OUStringBuffer aBuf;
2373 }
2375 {
2377 {
2389 }
2390 }
2392 {
2395 {
2403 ;
2404 }
2406 }
2408 {
2409 OUString aFmtStr;
2413 }
2415 {
2416 // 1 = negative values are colored, otherwise 0
2419 {
2422 }
2424 }
2426 {
2427 // 1 = format string contains a '(' character, otherwise 0
2430 {
2433 }
2435 }
2436 else
2438 }
2441 {
2445 {
2447 {
2448 ScAddress aAdr;
2452 }
2455 {
2456 ScRange aRange;
2460 }
2463 {
2467 }
2471 }
2474 }
2477 {
2481 {
2488 {
2489 ScAddress aAdr;
2493 ScRefCellValue aCell;
2496 {
2498 {
2507 }
2508 }
2509 }
2512 {
2517 {
2520 }
2521 else
2522 {
2529 }
2530 }
2534 }
2537 }
2540 {
2544 {
2547 {
2548 ScAddress aAdr;
2553 }
2557 }
2560 }
2563 {
2564 OUString aFormula;
2566 {
2569 {
2570 ScAddress aAdr;
2574 ScRefCellValue aCell;
2577 {
2583 }
2584 }
2589 }
2591 }
2594 {
2598 {
2601 {
2602 ScAddress aAdr;
2607 {
2608 ScRefCellValue aCell;
2612 }
2613 }
2616 {
2622 else
2623 {
2629 }
2630 }
2636 }
2639 }
2642 {
2646 {
2649 {
2650 ScAddress aAdr;
2654 else
2655 {
2656 ScRefCellValue aCell;
2660 }
2661 }
2664 {
2669 {
2672 }
2673 else
2674 {
2679 {
2682 }
2683 }
2684 }
2690 }
2693 }
2696 {
2700 {
2703 {
2704 ScAddress aAdr;
2706 {
2709 }
2712 else
2713 {
2714 ScRefCellValue aCell;
2717 }
2718 }
2721 {
2727 else
2728 {
2734 }
2735 }
2741 }
2744 }
2747 {
2752 {
2755 {
2756 ScAddress aAdr;
2760 ScRefCellValue aCell;
2765 else
2766 {
2768 {
2775 {
2778 }
2782 }
2783 }
2784 }
2787 {
2790 }
2793 {
2798 {
2802 }
2803 else
2804 {
2809 {
2813 }
2814 else
2816 }
2817 }
2821 }
2824 else
2827 }
2830 {
2832 }
2835 {
2837 }
2840 {
2843 // Temporarily override the ConvertStringToValue() error for
2844 // GetCellValue() / GetCellValueOrZero()
2854 }
2857 {
2858 // Doesn't only trim but also removes duplicated blanks within!
2860 OUStringBuffer aStr;
2864 {
2867 p++;
2868 }
2870 }
2873 {
2876 }
2879 {
2880 //2do: what to do with I18N-CJK ?!?
2884 {
2890 {
2894 else
2897 }
2898 }
2900 }
2903 {
2906 }
2909 {
2911 }
2914 {
2916 {
2919 {
2920 ScAddress aAdr;
2922 {
2925 }
2927 ScRefCellValue aCell;
2930 {
2932 {
2941 }
2942 }
2945 else
2946 {
2947 // like GetString()
2951 }
2952 }
2957 {
2963 else
2965 }
2968 {
2971 }
2978 }
2979 }
2982 {
2983 OUString aInputString;
2987 {
2998 {
2999 ScAddress aAdr;
3001 {
3004 }
3005 ScRefCellValue aCell;
3008 {
3012 }
3014 {
3017 }
3018 else
3019 {
3022 }
3023 }
3026 {
3029 aSS);
3032 {
3035 // fallthru
3041 // evaluated below
3045 }
3046 }
3051 }
3056 else
3058 }
3060 // fdo#57180
3062 {
3068 OUString aInputString;
3076 {
3080 else
3081 {
3084 }
3085 }
3088 {
3091 }
3094 {
3099 }
3101 {
3104 }
3106 {
3109 else
3112 }
3116 {
3120 {
3123 }
3126 else
3128 }
3131 {
3135 }
3138 {
3140 nPercentCount++;
3141 }
3143 rtl_math_ConversionStatus eStatus;
3144 sal_Int32 nParseEnd;
3145 double fVal = ::rtl::math::stringToDouble( aInputString, cDecimalSeparator, 0, &eStatus, &nParseEnd );
3147 {
3152 }
3154 }
3156 //2do: this should be a proper unicode string method
3158 {
3160 }
3163 {
3166 {
3169 }
3171 }
3174 {
3175 //2do: make it full range unicode?
3179 else
3180 {
3181 //"classic" ByteString conversion flags
3183 RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE |
3184 RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE |
3185 RTL_UNICODETOTEXT_FLAGS_FLUSH |
3186 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |
3187 RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT |
3188 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE;
3189 PushInt( (unsigned char) OUStringToOString(OUString(aStr[0]), osl_getThreadTextEncoding(), convertFlags).toChar() );
3190 }
3191 }
3194 {
3195 //2do: make it full range unicode?
3199 else
3200 {
3201 //"classic" ByteString conversion flags
3203 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT |
3204 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
3205 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT;
3210 }
3211 }
3213 /* #i70213# fullwidth/halfwidth conversion provided by
3214 * Takashi Nakamoto <bluedwarf@ooo>
3215 * erAck: added Excel compatibility conversions as seen in issue's test case. */
3218 {
3223 {
3226 }
3229 }
3232 {
3237 {
3240 }
3243 }
3245 /* ODFF:
3246 * Summary: Converts half-width to full-width ASCII and katakana characters.
3247 * Semantics: Conversion is done for half-width ASCII and katakana characters,
3248 * other characters are simply copied from T to the result. This is the
3249 * complementary function to ASC.
3250 * For references regarding halfwidth and fullwidth characters see
3251 * http://www.unicode.org/reports/tr11/
3252 * http://www.unicode.org/charts/charindex2.html#H
3253 * http://www.unicode.org/charts/charindex2.html#F
3254 */
3256 {
3259 }
3261 /* ODFF:
3262 * Summary: Converts full-width to half-width ASCII and katakana characters.
3263 * Semantics: Conversion is done for full-width ASCII and katakana characters,
3264 * other characters are simply copied from T to the result. This is the
3265 * complementary function to JIS.
3266 */
3268 {
3271 }
3274 {
3276 {
3280 else
3281 {
3284 }
3285 }
3286 }
3289 {
3291 {
3295 else
3296 {
3300 }
3301 }
3302 }
3305 {
3311 ScAddress aAdr;
3312 ScRange aRange;
3315 {
3317 {
3319 {
3323 }
3326 {
3328 ScRefCellValue aCell;
3331 {
3335 }
3337 {
3340 }
3341 }
3345 {
3350 {
3355 {
3358 }
3360 }
3361 }
3366 {
3369 {
3374 }
3375 }
3378 {
3381 {
3384 }
3385 else
3387 }
3392 }
3393 }
3396 else
3398 }
3401 {
3407 ScAddress aAdr;
3408 ScRange aRange;
3411 {
3413 {
3415 {
3419 }
3422 {
3424 ScRefCellValue aCell;
3427 {
3431 }
3433 {
3436 }
3437 }
3441 {
3446 {
3451 {
3454 }
3456 }
3457 }
3462 {
3465 {
3470 }
3471 }
3474 {
3477 {
3480 }
3481 else
3483 }
3488 }
3489 }
3492 else
3494 }
3498 {
3507 ScAddress aAdr;
3508 ScRange aRange;
3511 {
3513 {
3515 {
3519 rValCount++;
3520 }
3523 {
3525 ScRefCellValue aCell;
3528 {
3532 rValCount++;
3533 }
3535 {
3537 rValCount++;
3538 }
3539 }
3543 {
3548 {
3549 do
3550 {
3553 rValCount++;
3554 }
3556 }
3557 }
3560 {
3563 {
3567 {
3569 {
3571 {
3575 rValCount++;
3576 }
3578 {
3580 rValCount++;
3581 }
3582 }
3583 }
3584 }
3585 }
3588 {
3591 {
3593 rValCount++;
3594 }
3595 else
3597 }
3602 }
3603 }
3610 }
3613 {
3620 else
3622 }
3625 {
3631 }
3634 {
3640 else
3642 }
3645 {
3651 else
3654 /* this was: PushDouble( sqrt( div( nVal, nValCount)));
3655 *
3656 * Besides that the special NAN gets lost in the call through sqrt(),
3657 * unxlngi6.pro then looped back and forth somewhere between div() and
3658 * ::rtl::math::setNan(). Tests showed that
3659 *
3660 * sqrt( div( 1, 0));
3661 *
3662 * produced a loop, but
3663 *
3664 * double f1 = div( 1, 0);
3665 * sqrt( f1 );
3666 *
3667 * was fine. There seems to be some compiler optimization problem. It does
3668 * not occur when compiled with debug=t.
3669 */
3670 }
3673 {
3676 SCCOL nCol1;
3677 SCROW nRow1;
3678 SCTAB nTab1;
3679 SCCOL nCol2;
3680 SCROW nRow2;
3681 SCTAB nTab2;
3683 {
3685 {
3688 nVal++;
3696 {
3699 {
3703 }
3704 }
3708 nVal++;
3711 {
3712 sal_uInt16 nFileId;
3713 OUString aTabName;
3714 ScComplexRefData aRef;
3719 }
3724 }
3725 }
3727 }
3730 {
3733 SCCOL nCol1;
3734 SCROW nRow1;
3735 SCTAB nTab1;
3736 SCCOL nCol2;
3737 SCROW nRow2;
3738 SCTAB nTab2;
3740 {
3742 {
3745 nVal++;
3753 {
3756 {
3760 }
3761 }
3765 nVal++;
3768 {
3769 sal_uInt16 nFileId;
3770 OUString aTabName;
3771 ScComplexRefData aRef;
3776 }
3781 }
3782 }
3784 }
3787 {
3789 sal_uLong nVal;
3792 else
3793 {
3795 SCCOL nCol1;
3796 SCROW nRow1;
3797 SCTAB nTab1;
3798 SCCOL nCol2;
3799 SCROW nRow2;
3800 SCTAB nTab2;
3802 {
3804 {
3807 nVal++;
3815 nVal++;
3819 nVal++;
3822 {
3823 sal_uInt16 nFileId;
3824 OUString aTabName;
3825 ScComplexRefData aRef;
3829 }
3834 }
3835 }
3836 }
3838 }
3841 {
3844 {
3847 {
3850 {
3851 SCCOL nCols;
3852 SCROW nRows;
3855 {
3856 // Happens if called via ScViewFunc::EnterMatrix()
3857 // ScFormulaCell::GetResultDimensions() as of course a
3858 // matrix result is not available yet.
3860 }
3863 {
3868 }
3869 }
3870 }
3871 else
3872 {
3874 {
3876 {
3877 SCCOL nCol1;
3878 SCROW nRow1;
3879 SCTAB nTab1;
3882 }
3885 {
3886 SCCOL nCol1;
3887 SCROW nRow1;
3888 SCTAB nTab1;
3889 SCCOL nCol2;
3890 SCROW nRow2;
3891 SCTAB nTab2;
3894 {
3898 {
3904 }
3905 else
3907 }
3908 else
3910 }
3915 }
3916 }
3918 }
3919 }
3922 {
3925 {
3928 {
3931 {
3932 SCCOL nCols;
3933 SCROW nRows;
3936 {
3937 // Happens if called via ScViewFunc::EnterMatrix()
3938 // ScFormulaCell::GetResultDimensions() as of course a
3939 // matrix result is not available yet.
3941 }
3944 {
3949 }
3950 }
3951 }
3952 else
3953 {
3955 {
3957 {
3958 SCCOL nCol1;
3959 SCROW nRow1;
3960 SCTAB nTab1;
3963 }
3966 {
3967 SCCOL nCol1;
3968 SCROW nRow1;
3969 SCTAB nTab1;
3970 SCCOL nCol2;
3971 SCROW nRow2;
3972 SCTAB nTab2;
3975 {
3979 {
3985 }
3986 else
3988 }
3989 else
3991 }
3996 }
3997 }
3999 }
4000 }
4003 {
4006 {
4010 else
4011 {
4013 {
4015 {
4019 else
4021 }
4024 {
4025 SCCOL nCol1;
4026 SCROW nRow1;
4027 SCTAB nTab1;
4030 }
4033 {
4034 SCCOL nCol1;
4035 SCROW nRow1;
4036 SCTAB nTab1;
4037 SCCOL nCol2;
4038 SCROW nRow2;
4039 SCTAB nTab2;
4042 }
4046 }
4049 }
4051 }
4052 }
4056 class VectorMatrixAccessor
4057 {
4063 {
4065 }
4068 {
4070 }
4073 {
4075 }
4078 {
4080 }
4083 {
4085 }
4088 {
4090 }
4093 {
4097 }
4102 };
4104 /** returns -1 when the matrix value is smaller than the query value, 0 when
4105 they are equal, and 1 when the matrix value is larger than the query
4106 value. */
4109 {
4111 {
4112 /* TODO: in case we introduced query for real empty this would have to
4113 * be changed! */
4115 }
4117 /* FIXME: what is an empty path (result of IF(false;true_path) in
4118 * comparisons? */
4122 {
4132 }
4141 }
4143 /** returns the last item with the identical value as the original item
4144 value. */
4147 {
4149 {
4155 else
4159 }
4160 // Order of IsEmptyPath, IsEmpty, IsString is significant!
4162 {
4166 else
4169 }
4171 {
4175 else
4178 }
4180 {
4186 else
4190 }
4191 else
4192 {
4194 }
4195 }
4197 }
4200 {
4204 {
4208 else
4219 {
4227 {
4230 {
4233 }
4234 }
4238 {
4241 else
4245 {
4248 }
4249 }
4254 }
4257 {
4259 ScQueryParam rParam;
4273 {
4275 {
4279 }
4282 {
4285 }
4289 {
4290 ScAddress aAdr;
4292 {
4295 }
4296 ScRefCellValue aCell;
4299 {
4303 }
4304 else
4305 {
4308 }
4309 }
4312 {
4316 {
4319 }
4321 {
4324 }
4325 else
4326 {
4329 }
4330 }
4333 // TODO: Implement this.
4338 {
4345 }
4348 {
4351 }
4352 }
4354 {
4357 // #TODO handle MSO wildcards
4360 else
4362 }
4365 {
4369 {
4370 // The source matrix must be a vector.
4373 }
4377 // simple serial search for equality mode (source data doesn't
4378 // need to be sorted).
4381 {
4383 {
4385 {
4388 }
4389 }
4392 }
4394 // binary search for non-equality mode (the source data is
4395 // assumed to be sorted).
4400 {
4404 {
4405 // exact match. find the last item with the same value.
4409 }
4412 {
4415 else
4418 }
4421 {
4424 else
4426 }
4427 else
4428 {
4431 else
4433 }
4434 }
4437 {
4440 {
4441 // either the last item is an exact match or the real
4442 // hit is beyond the last item.
4445 }
4446 }
4449 {
4452 }
4456 }
4465 {
4468 }
4470 }
4471 else
4473 SCCOL nC;
4478 // Advance Entry.nField in Iterator if column changed
4484 else
4485 {
4488 }
4489 }
4490 else
4492 SCROW nR;
4494 {
4497 }
4498 }
4500 }
4502 }
4503 else
4505 }
4506 }
4511 {
4513 {
4519 {
4520 // NOTE: Excel treats ="" in a referenced cell as blank in
4521 // COUNTBLANK() but not in ISBLANK(), which is inconsistent.
4522 // COUNTBLANK() tests the (display) result whereas ISBLANK() tests
4523 // the cell content.
4524 // ODFF allows both for COUNTBLANK().
4525 // OOo and LibreOffice prior to 4.4 did not treat ="" as blank in
4526 // COUNTBLANK(), we now do for Excel interoperability.
4527 /* TODO: introduce yet another compatibility option? */
4533 }
4536 ;
4537 }
4540 }
4542 }
4545 {
4547 {
4550 {
4552 {
4554 ScAddress aAdr;
4556 ScRefCellValue aCell;
4560 }
4564 {
4565 ScRange aRange;
4569 {
4571 nMaxCount +=
4578 {
4582 }
4583 }
4584 }
4587 }
4589 }
4590 }
4593 {
4602 ScMatrixRef pSumExtraMatrix;
4605 {
4606 // Save only the upperleft cell in case of cell range. The geometry
4607 // of the 3rd parameter is taken from the 1st parameter.
4610 {
4612 {
4618 {
4621 }
4622 }
4629 // nCol3, nRow3, nTab3 remain 0
4632 {
4637 {
4640 }
4644 else
4646 }
4654 }
4655 }
4661 {
4664 {
4665 ScAddress aAdr;
4669 ScRefCellValue aCell;
4672 {
4679 {
4682 }
4683 else
4693 }
4694 }
4701 {
4704 }
4707 {
4711 {
4713 {
4716 }
4717 else
4719 }
4720 }
4723 {
4726 }
4727 }
4737 {
4744 ScMatrixRef pQueryMatrix;
4746 {
4749 {
4751 }
4752 else
4753 {
4754 ScRange aRange;
4757 }
4771 {
4774 {
4777 }
4786 }
4790 }
4792 {
4794 }
4797 {
4798 // Take the range geometry of the 1st parameter and apply it to
4799 // the 3rd. If parts of the resulting range would point outside
4800 // the sheet, don't complain but silently ignore and simply cut
4801 // them away, this is what Xcl does :-/
4803 // For the cut-away part we also don't need to determine the
4804 // criteria match, so shrink the source range accordingly,
4805 // instead of the result range.
4808 SCCOL nMaxCol;
4809 SCROW nMaxRow;
4811 {
4816 }
4817 else
4818 {
4821 }
4823 {
4826 }
4829 {
4832 }
4833 }
4834 else
4835 {
4839 }
4842 {
4843 ScQueryParam rParam;
4851 {
4855 }
4856 else
4857 {
4861 }
4862 ScAddress aAdr;
4870 {
4871 // Never case-sensitive.
4875 {
4877 }
4880 {
4882 {
4884 {
4887 {
4891 {
4895 {
4898 }
4899 else
4901 }
4902 }
4903 }
4904 }
4905 }
4906 else
4907 {
4909 {
4911 {
4913 {
4916 ScRefCellValue aCell;
4919 {
4923 {
4926 }
4927 else
4929 }
4930 }
4931 }
4932 }
4933 }
4934 }
4935 else
4936 {
4938 // Increment Entry.nField in iterator when switching to next column.
4941 {
4943 {
4944 do
4945 {
4949 {
4953 {
4956 }
4957 else
4959 }
4961 }
4962 else
4963 {
4964 do
4965 {
4968 ScRefCellValue aCell;
4971 {
4975 {
4978 }
4979 else
4981 }
4983 }
4984 }
4985 }
4986 }
4987 else
4988 {
4991 }
4992 }
4995 {
4998 }
5000 }
5003 {
5005 }
5008 {
5010 }
5013 {
5015 {
5020 {
5023 {
5024 ScAddress aAdr;
5026 {
5029 }
5030 ScRefCellValue aCell;
5033 {
5040 {
5043 }
5044 else
5054 }
5055 }
5060 {
5063 }
5069 {
5072 }
5073 }
5078 {
5085 ScMatrixRef pQueryMatrix;
5087 {
5090 {
5091 ScRange aRange;
5094 }
5105 {
5108 {
5111 }
5120 }
5125 }
5127 {
5130 }
5132 {
5135 }
5137 {
5138 ScQueryParam rParam;
5146 {
5150 }
5151 else
5152 {
5156 }
5161 {
5162 // Never case-sensitive.
5166 {
5169 }
5173 {
5177 }
5178 }
5179 else
5180 {
5182 // Keep Entry.nField in iterator on column change
5185 {
5186 do
5187 {
5188 fCount++;
5190 }
5191 }
5192 }
5193 else
5194 {
5197 }
5198 }
5200 }
5201 }
5204 {
5211 else
5215 {
5217 }
5218 else
5219 {
5234 {
5235 // take criteria
5240 {
5243 {
5244 ScAddress aAdr;
5248 ScRefCellValue aCell;
5251 {
5258 {
5261 }
5262 else
5272 }
5273 }
5280 {
5283 }
5286 {
5290 {
5292 {
5295 }
5296 else
5298 }
5299 }
5302 {
5305 }
5306 }
5311 // take range
5320 ScMatrixRef pQueryMatrix;
5322 {
5324 {
5325 ScRange aRange;
5328 }
5342 {
5345 {
5348 }
5357 }
5362 }
5364 {
5367 }
5369 // All reference ranges must be of same dimension and size.
5375 {
5378 }
5380 // recalculate matrix values
5384 // initialize temporary result matrix
5386 {
5390 }
5392 ScQueryParam rParam;
5400 {
5404 }
5405 else
5406 {
5410 }
5411 ScAddress aAdr;
5419 {
5420 // Never case-sensitive.
5424 {
5427 }
5429 // result matrix is filled with boolean values.
5433 {
5436 }
5442 }
5443 else
5444 {
5446 // Increment Entry.nField in iterator when switching to next column.
5449 {
5450 do
5451 {
5456 }
5457 }
5459 }
5464 // main range - only for AVERAGEIFS and SUMIFS
5466 {
5476 ScMatrixRef pMainMatrix;
5478 {
5480 {
5481 ScRange aRange;
5484 }
5498 {
5501 {
5504 }
5513 }
5518 }
5520 {
5523 }
5525 // All reference ranges must be of same dimension and size.
5526 if ((nDimensionCols != (nMainCol2 - nMainCol1 + 1)) || (nDimensionRows != (nMainRow2 - nMainRow1 + 1)))
5527 {
5530 }
5535 // end-result calculation
5536 ScAddress aAdr;
5539 {
5543 {
5546 }
5551 {
5561 {
5564 }
5565 else
5567 }
5568 }
5569 else
5570 {
5573 {
5575 {
5577 {
5580 ScRefCellValue aCell;
5583 {
5587 {
5590 }
5591 else
5593 }
5594 }
5595 }
5596 }
5597 }
5598 }
5599 else
5600 {
5605 }
5608 {
5613 }
5615 }
5617 }
5620 {
5622 }
5625 {
5627 }
5630 {
5632 }
5635 {
5647 // The third parameter, result array, for double, string and single reference.
5650 ScAddress aResAdr;
5654 {
5657 {
5659 {
5660 SCTAB nTabJunk;
5665 {
5666 // The result array must be a vector.
5669 }
5670 }
5675 {
5678 {
5681 }
5685 {
5686 // Result matrix must be a vector.
5689 }
5690 }
5704 }
5705 }
5707 // For double, string and single reference.
5710 ScAddress aDataAdr;
5713 // Get the data-result range and also determine whether this is vertical
5714 // lookup or horizontal lookup.
5718 {
5720 {
5721 SCTAB nTabJunk;
5724 {
5727 }
5730 }
5735 {
5738 {
5741 }
5747 }
5750 {
5753 }
5756 {
5758 }
5761 {
5763 ScRefCellValue aCell;
5766 {
5767 // Empty cells aren't found anywhere, bail out early.
5769 }
5771 {
5774 }
5775 else
5777 }
5781 }
5784 {
5787 }
5789 // Get the lookup value.
5791 ScQueryParam aParam;
5798 {
5799 // Delta position for a single value is always 0.
5801 // Found if data <= query, but not if query is string and found data is
5802 // numeric or vice versa. This is how Excel does it but doesn't
5803 // document it.
5809 {
5812 else
5814 }
5815 else
5816 {
5819 else
5820 bFound = (ScGlobal::GetCollator()->compareString(aDataStr.getString(), rItem.maString.getString()) <= 0);
5821 }
5824 {
5827 }
5830 {
5833 else
5835 }
5837 {
5839 {
5848 // fallthru
5854 }
5855 }
5856 else
5857 {
5859 {
5871 }
5872 }
5874 }
5876 // Now, perform the search to compute the delta position (nDelta).
5879 {
5880 // Data array is given as a matrix.
5888 // In case of non-vector matrix, only search the first row or column.
5889 ScMatrixRef pDataMat2;
5891 {
5896 else
5899 }
5900 else
5901 {
5906 else
5909 }
5913 // binary search for non-equality mode (the source data is
5914 // assumed to be sorted in ascending order).
5920 {
5924 {
5925 // exact match. find the last item with the same value.
5930 }
5933 {
5935 // If already the 1st item is greater there's nothing found.
5938 }
5942 else
5944 }
5947 {
5950 {
5951 // either the last item is an exact match or the real
5952 // hit is beyond the last item.
5955 }
5956 }
5958 {
5959 // non-exact match
5961 }
5963 // With 0-9 < A-Z, if query is numeric and data found is string, or
5964 // vice versa, the (yet another undocumented) Excel behavior is to
5965 // return #N/A instead.
5968 {
5977 }
5980 {
5983 }
5985 // Now that we've found the delta, push the result back to the cell.
5988 {
5990 // result array is matrix.
5992 {
5995 }
5998 else
6000 }
6002 {
6003 // result array is cell range.
6004 ScAddress aAdr;
6008 {
6011 {
6014 }
6017 }
6018 else
6019 {
6022 {
6025 }
6028 }
6030 }
6031 else
6032 {
6033 // no result array. Use the data array to get the final value from.
6035 {
6038 else
6040 }
6041 else
6042 {
6045 else
6047 }
6048 }
6051 }
6053 // Perform cell range search.
6069 SCCOL nC;
6070 SCROW nR;
6071 // Advance Entry.nField in iterator upon switching columns if
6072 // lookup in row.
6075 {
6078 }
6083 {
6085 // Use the matrix result array.
6088 else
6090 }
6092 {
6094 {
6096 {
6097 // Use the result array vector. Note that the result array is assumed
6098 // to be a vector (i.e. 1-dimensinoal array).
6100 ScAddress aAdr;
6104 {
6107 {
6110 }
6113 }
6114 else
6115 {
6118 {
6121 }
6124 }
6126 }
6131 {
6134 else
6135 {
6137 {
6149 }
6150 }
6151 }
6155 }
6156 }
6157 else
6158 {
6159 // Regardless of whether or not the result array exists, the last
6160 // array is always used as the "result" array.
6162 ScAddress aAdr;
6165 {
6168 {
6171 }
6174 }
6175 else
6176 {
6179 {
6182 }
6185 }
6187 }
6188 }
6191 {
6193 }
6196 {
6201 // Optional 4th argument to declare whether or not the range is sorted.
6206 // Index of column to search.
6216 SCTAB nTab2;
6219 {
6222 {
6225 }
6226 }
6228 {
6232 }
6234 {
6239 else
6240 {
6243 }
6244 }
6245 else
6246 {
6249 }
6251 if ( fIndex < 0.0 || (bHLookup ? (pMat ? (fIndex >= nR) : (fIndex+nRow1 > nRow2)) : (pMat ? (fIndex >= nC) : (fIndex+nCol1 > nCol2)) ) )
6252 {
6255 }
6261 {
6264 }
6267 {
6270 }
6272 ScQueryParam aParam;
6276 {
6280 }
6281 else
6282 {
6286 }
6299 {
6303 {
6304 //!!!!!!!
6305 //TODO: enable regex on matrix strings
6306 //!!!!!!!
6309 {
6312 {
6314 {
6315 sal_Int32 nRes =
6317 bHLookup ? pMat->GetString(i,0).getString() : pMat->GetString(0,i).getString(), aParamStr.getString());
6322 }
6323 else
6325 }
6326 }
6327 else
6328 {
6330 {
6332 {
6334 {
6336 {
6339 }
6340 }
6341 }
6342 }
6343 else
6344 {
6346 }
6347 }
6348 }
6349 else
6350 {
6352 {
6353 // #i2168# ignore strings
6355 {
6357 {
6360 else
6362 }
6363 }
6364 }
6365 else
6366 {
6368 {
6370 {
6372 {
6374 {
6377 }
6378 }
6379 }
6380 }
6381 else
6382 {
6384 }
6385 }
6386 }
6388 {
6392 {
6395 }
6398 else
6400 }
6401 else
6403 }
6404 else
6405 {
6413 {
6415 // advance Entry.nField in Iterator upon switching columns
6418 {
6419 SCROW nRow1_temp;
6421 }
6423 {
6426 }
6428 }
6429 else
6430 {
6435 }
6438 {
6441 }
6442 else
6444 }
6445 }
6448 {
6451 {
6453 {
6456 }
6459 {
6462 }
6466 {
6467 ScAddress aAdr;
6469 {
6472 }
6473 ScRefCellValue aCell;
6476 {
6479 }
6480 else
6481 {
6484 }
6485 }
6488 {
6494 }
6497 {
6500 }
6503 }
6505 {
6507 }
6510 {
6513 {
6514 // We must fish the 1st parameter deep from the stack! And push it on top.
6520 {
6521 // For opcodes 101 through 111, we need to skip hidden cells.
6522 // Other than that these opcodes are identical to 1 through 11.
6525 }
6529 else
6530 {
6533 {
6546 }
6547 }
6549 // Get rid of the 1st (fished) parameter.
6553 }
6554 }
6557 {
6560 {
6561 // fish the 1st parameter from the stack and push it on top.
6565 // fish the 2nd parameter from the stack and push it on top.
6572 else
6573 {
6575 {
6603 }
6607 {
6628 }
6630 }
6632 // Get rid of the 1st and 2nd (fished) parameters.
6636 }
6637 }
6640 {
6643 {
6646 }
6648 {
6649 // First, get the query criteria range.
6657 ScRange aMissingRange;
6660 {
6671 {
6672 ScAddress aAdr;
6674 ScRefCellValue aCell;
6678 else
6679 {
6682 }
6683 }
6690 }
6691 else
6692 {
6695 }
6701 else
6707 }
6718 {
6719 // range parameter must match entire database range
6722 else
6724 }
6734 else
6735 {
6739 }
6747 {
6748 // An allowed missing field parameter sets the result field
6749 // to any of the query fields, just to be able to return
6750 // some cell from the iterator.
6757 {
6771 }
6773 }
6774 }
6776 }
6779 {
6787 {
6789 {
6792 }
6796 {
6798 {
6803 }
6804 do
6805 {
6806 nCount++;
6808 {
6812 {
6815 }
6816 else
6824 }
6825 }
6827 }
6829 }
6830 else
6833 {
6838 }
6840 }
6843 {
6845 }
6848 {
6852 {
6856 // TODO: currently the QueryIterators only return cell pointers of
6857 // existing cells, so if a query matches an empty cell there's
6858 // nothing returned, and therefore not counted!
6859 // Since this has ever been the case and this code here only came
6860 // into existence to fix #i6899 and it never worked before we'll
6861 // have to live with it until we reimplement the iterators to also
6862 // return empty cells, which would mean to adapt all callers of
6863 // iterators.
6867 // ScQueryCellIterator doesn't make use of ScDBQueryParamBase::mnField,
6868 // so the source range has to be restricted, like before the introduction
6869 // of ScDBQueryParamBase.
6873 {
6874 do
6875 {
6876 nCount++;
6878 }
6879 }
6880 else
6883 {
6886 }
6890 {
6891 do
6892 {
6893 nCount++;
6894 }
6896 }
6898 }
6900 }
6901 else
6903 }
6906 {
6910 {
6912 {
6915 }
6921 {
6922 do
6923 {
6924 nCount++;
6925 }
6927 }
6930 }
6931 else
6933 }
6936 {
6938 }
6941 {
6943 }
6946 {
6948 }
6951 {
6953 }
6956 {
6966 {
6968 {
6971 }
6975 {
6976 do
6977 {
6978 rValCount++;
6981 }
6983 }
6985 }
6986 else
6995 }
6998 {
7002 }
7005 {
7009 }
7012 {
7016 }
7019 {
7023 }
7026 {
7029 {
7030 // Reference address syntax for INDIRECT is configurable.
7033 // Use the current address syntax if unspecified.
7036 // either CONV_A1_XL_A1 was explicitly configured, or it wasn't possible
7037 // to determine which syntax to use during doc import
7041 {
7042 // Overwrite the config and try Excel R1C1.
7045 }
7056 {
7058 {
7063 }
7064 else
7066 }
7070 {
7072 {
7075 }
7076 else
7078 }
7079 else
7080 {
7081 do
7082 {
7087 // We need this in order to obtain a good range.
7090 ScRange aRange;
7092 // This is the usual way to treat named ranges containing
7093 // relative references.
7100 else
7105 // success!
7107 }
7110 do
7111 {
7118 ScRange aRange;
7121 // In Excel, specifying a table name without [] resolves to the
7122 // same as with [], a range that excludes header and totals
7123 // rows and contains only data rows. Do the same.
7135 else
7140 // success!
7142 }
7145 // It may be even a TableRef.
7146 // Anything else that resolves to one reference could be added
7147 // here, but we don't want to compile every arbitrary string. This
7148 // is already nasty enough..
7151 {
7152 do
7153 {
7159 // Whatever.. use only the specific case.
7165 // A syntactically valid reference will generate exactly
7166 // one RPN token, a reference or error. Discard everything
7167 // else as error.
7176 {
7181 // success!
7185 }
7186 }
7188 }
7191 }
7192 }
7193 }
7196 {
7197 OUString sTabStr;
7212 {
7215 {
7228 }
7229 }
7235 {
7236 // YUCK! The XL interface actually treats rel R1C1 refs differently
7237 // than A1
7242 }
7247 {
7250 }
7257 {
7258 OUString aDoc;
7260 {
7261 // Isolate Tab from 'Doc'#Tab
7264 {
7269 }
7270 }
7271 /* TODO: yet unsupported external reference in CONV_XL_R1C1 syntax may
7272 * need some extra handling to isolate Tab from Doc. */
7280 }
7281 else
7283 }
7286 {
7289 {
7304 {
7307 }
7309 {
7311 {
7314 {
7319 else
7321 }
7322 else
7323 {
7335 else
7337 }
7339 }
7341 {
7342 sal_uInt16 nFileId;
7343 OUString aTabName;
7344 ScSingleRefData aRef;
7352 {
7357 else
7359 }
7360 else
7361 {
7374 else
7376 }
7378 }
7380 {
7393 else
7396 }
7398 {
7399 sal_uInt16 nFileId;
7400 OUString aTabName;
7401 ScComplexRefData aRef;
7421 else
7424 }
7429 }
7430 }
7433 {
7436 {
7439 SCCOL nCol;
7440 SCROW nRow;
7443 else
7447 else
7451 else
7455 else
7458 {
7461 }
7463 {
7466 }
7468 {
7472 {
7478 {
7481 // Access one element of a vector independent of col/row
7482 // orientation?
7494 {
7498 else
7500 }
7502 {
7505 {
7511 else
7515 }
7516 else
7518 }
7520 {
7523 {
7529 else
7532 }
7533 else
7535 }
7536 else
7537 {
7543 else
7547 }
7548 }
7549 }
7552 {
7559 else
7561 }
7565 {
7574 {
7577 {
7580 }
7586 }
7587 else
7588 {
7592 }
7599 {
7602 else
7604 }
7606 {
7609 else
7612 }
7614 {
7618 {
7622 }
7623 else
7626 }
7627 else
7629 }
7633 }
7634 }
7635 }
7638 {
7639 // Legacy support, convert to RefList
7642 {
7644 {
7646 }
7647 }
7648 }
7651 {
7654 {
7657 {
7659 {
7663 }
7666 {
7670 }
7673 {
7677 }
7681 }
7683 }
7684 }
7687 {
7690 {
7691 OUString aStr;
7694 {
7697 {
7700 }
7701 }
7702 else
7708 else
7712 else
7721 {
7723 nIndex,
7730 fVal,
7731 aStr,
7735 }
7736 else
7737 {
7739 }
7741 }
7742 }
7745 {
7747 {
7754 else
7755 {
7767 }
7768 }
7769 }
7772 {
7775 {
7776 OUString aStr;
7781 else
7784 {
7787 {
7790 }
7791 }
7792 else
7798 else
7802 else
7811 nIndex,
7818 fVal,
7819 aStr,
7823 else
7825 }
7826 }
7829 {
7832 {
7833 sal_Int32 nAnz;
7836 else
7841 else
7842 {
7846 else
7848 }
7849 }
7850 }
7853 {
7856 {
7860 }
7861 }
7864 {
7867 {
7868 sal_Int32 n;
7870 {
7873 {
7876 }
7877 else
7879 }
7880 else
7886 }
7887 }
7890 UBlockCode from;
7891 UBlockCode to;
7903 };
7904 #define scriptListCount sizeof (scriptList) / sizeof (UBlockScript)
7906 {
7907 // for the locale of ja-JP, character U+0x005c and U+0x20ac should be ScriptType::Asian
7911 sal_uInt16 i;
7916 }
7919 }
7921 {
7923 }
7925 {
7933 else
7934 length++;
7935 index++;
7936 }
7938 }
7940 {
7942 }
7944 {
7946 {
7950 {
7952 {
7955 }
7957 {
7961 }
7964 else
7965 n--;
7966 }
7968 }
7970 }
7972 {
7975 {
7976 sal_Int32 n;
7978 {
7981 {
7984 }
7985 else
7987 }
7988 else
7992 }
7993 }
7995 {
7997 {
8001 {
8003 {
8006 }
8008 {
8012 }
8015 else
8016 n--;
8017 }
8019 }
8021 }
8023 {
8026 {
8027 sal_Int32 n;
8029 {
8032 {
8035 }
8036 else
8038 }
8039 else
8043 }
8044 }
8046 {
8048 {
8054 else
8055 {
8061 }
8062 }
8063 }
8066 {
8069 {
8070 sal_Int32 n;
8072 {
8075 {
8078 }
8079 else
8081 }
8082 else
8088 }
8089 }
8092 {
8095 {
8098 {
8099 // This should use GetStringPositionArgument() but old versions up
8100 // to LibreOffice 4.2.5 allowed and ignored 0 and negative values.
8101 // It is unnecessary to break existing documents that "rely" on
8102 // that behavior. Though ODFF constrains Start to be >=1.
8103 /* TODO: fix this and possibly break those broken documents? */
8108 {
8111 }
8112 }
8113 else
8121 else
8122 {
8131 else
8133 }
8134 }
8135 }
8138 {
8140 {
8146 else
8147 {
8148 sal_Int32 nCharacters = std::min<sal_Int32>(static_cast<sal_Int32>(fAnz), aStr.getLength() - fAnfang + 1);
8149 OUString sRes;
8153 }
8154 }
8155 }
8158 {
8160 {
8166 {
8174 {
8177 {
8179 // Temporarily override the ConvertStringToValue()
8180 // error for GetCellValue() / GetCellValueOrZero()
8186 {
8187 // Not numeric.
8192 }
8193 }
8194 }
8195 }
8198 else
8199 {
8200 OUString aResult;
8202 LanguageType eCellLang;
8208 else
8211 {
8215 else
8217 }
8218 else
8219 {
8223 else
8225 }
8226 }
8227 }
8228 }
8231 {
8234 {
8235 sal_Int32 nAnz;
8237 {
8240 {
8243 }
8244 else
8246 }
8247 else
8257 {
8260 {
8261 nCount++;
8263 {
8266 {
8269 }
8270 else
8272 }
8273 else
8274 nPos++;
8275 }
8276 else
8278 }
8280 }
8281 }
8284 {
8286 {
8292 {
8294 }
8297 else
8298 {
8305 }
8306 }
8307 }
8310 {
8312 OUString aRes;
8314 {
8317 }
8319 }
8322 {
8323 sal_uInt16 nErr;
8327 {
8329 {
8333 else
8334 {
8341 else
8342 {
8343 ScRange aRange;
8347 else
8348 {
8349 ScAddress aAdr;
8352 else
8354 }
8355 }
8356 }
8357 }
8360 {
8361 ScRange aRange;
8365 else
8366 {
8367 ScAddress aAdr;
8370 else
8372 }
8373 }
8376 {
8377 ScAddress aAdr;
8381 else
8383 }
8388 }
8391 }
8394 {
8397 {
8400 }
8401 else
8402 {
8404 }
8405 }
8408 {
8410 sal_uInt16 nErrType;
8413 {
8435 /*
8436 #GETTING_DATA is a message that can appear in Excel when a large or
8437 complex worksheet is being calculated. In Excel 2007 and newer,
8438 operations are grouped so more complicated cells may finish after
8439 earlier ones do. While the calculations are still processing, the
8440 unfinished cells may display #GETTING_DATA.
8441 Because the message is temporary and disappears when the calculations
8442 complete, this isn’t a true error.
8443 No calc error code known (yet).
8445 case : // GETTING_DATA
8446 nErrType = 8;
8447 break;
8448 */
8452 }
8455 {
8458 }
8459 else
8461 }
8464 {
8469 static const sal_Unicode cre[] = { '.','*','+','?','[',']','^','$','\\','<','>','(',')','|', 0 };
8471 sal_Unicode c1;
8473 {
8476 {
8479 }
8480 }
8482 }
8486 {
8490 {
8491 // range lookup <= or >=
8492 SCCOL nCol;
8493 SCROW nRow;
8496 {
8499 }
8500 }
8502 {
8503 // EQUAL
8507 }
8509 }
8513 {
8518 // At least all volatile functions that generate indirect references have
8519 // to force non-cached lookup.
8520 /* TODO: We could further classify volatile functions into reference
8521 * generating and not reference generating functions to have to force less
8522 * direct lookups here. We could even further attribute volatility per
8523 * parameter so it would affect only the lookup range parameter. */
8526 else
8527 {
8535 {
8548 }
8549 }
8551 }
8553 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */