| blob | 2a048ae90a0ae9952dda2bb32845db42f8f403ce |
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 <osl/thread.h>
26 #include <svx/algitem.hxx>
27 #include <unotools/textsearch.hxx>
28 #include <svl/zforlist.hxx>
29 #include <svl/zformat.hxx>
30 #include <tools/urlobj.hxx>
31 #include <unotools/charclass.hxx>
32 #include <sfx2/docfile.hxx>
33 #include <sfx2/printer.hxx>
34 #include <unotools/collatorwrapper.hxx>
35 #include <unotools/transliterationwrapper.hxx>
36 #include <rtl/ustring.hxx>
37 #include <unicode/uchar.h>
56 #include <basic/sbstar.hxx>
63 #include <comphelper/processfactory.hxx>
64 #include <comphelper/string.hxx>
67 #include <stdlib.h>
68 #include <string.h>
69 #include <math.h>
70 #include <vector>
71 #include <memory>
72 #include <limits>
87 {
92 {
94 {
98 else
99 {
100 FormulaTokenRef xNew;
102 // DoubleError handled by JumpMatrix
107 {
110 }
114 else
115 {
118 {
120 {
125 {
131 }
132 else
133 {
134 // Treat empty and empty path as 0, but string
135 // as error.
139 }
147 }
148 else
153 }
154 }
155 else
162 }
163 else
165 // or DoubleError
169 }
170 }
171 }
172 }
175 }
177 // set endpoint of path for main code line
179 }
180 }
183 {
189 }
190 else
195 }
196 }
197 else
202 }
203 else
208 }
209 }
210 }
211 }
212 }
215 /** Store a matrix value in another matrix in the context of that other matrix
216 is the result matrix of a jump matrix. All arguments must be valid and are
217 not checked. */
220 {
222 {
225 }
227 {
229 }
230 else
231 {
233 }
234 }
238 {
242 {
246 }
255 {
265 {
266 ScAddress aAdr;
269 else
270 {
272 ScRefCellValue aCell;
277 }
278 }
282 {
285 // Handles also existing jump matrix case and sets error on
286 // elements.
290 }
293 {
296 {
299 }
300 // If the matrix has no queried error at all we can simply use
301 // it as result and don't need to bother with jump matrix.
307 {
310 }
312 {
314 {
317 {
321 }
322 }
323 }
327 FormulaTokenRef xNew;
330 {
332 }
333 else
334 {
337 // Init all jumps to no error to save single calls. Error
338 // is the exceptional condition.
341 // Up to first error position simply store results, no need
342 // to evaluate error conditions again.
345 {
347 {
349 }
352 }
353 // Now the mixed cases.
355 {
357 {
362 }
363 else
366 }
367 }
368 }
371 }
374 // set endpoint of path for main code line
377 }
379 }
382 {
383 // error, calculate 2nd argument
386 }
387 else
388 {
389 // no error, push 1st argument and continue
393 }
394 }
398 {
399 // We have to set a jump, if there was none chosen because of an error set
400 // it to endpoint.
406 {
408 {
412 else
413 {
414 FormulaTokenRef xNew;
416 // DoubleError handled by JumpMatrix
425 else
426 {
429 {
431 {
435 {
439 {
442 {
445 errIllegalArgument);
446 }
447 }
448 }
449 else
450 {
452 }
454 {
458 }
459 else
460 {
464 }
465 }
466 }
470 }
472 // set endpoint of path for main code line
475 }
476 }
479 {
482 {
485 }
486 else
488 }
489 }
492 }
495 {
503 {
505 {
508 }
510 {
513 }
514 else
515 {
518 }
520 }
521 }
524 {
529 {
532 else
533 {
535 }
538 {
541 }
542 else
543 {
546 {
548 {
551 {
554 }
556 }
559 {
562 {
566 }
567 else
569 }
572 {
573 ScAddress aAdr;
576 {
580 }
581 else
582 {
583 ScRefCellValue aCell;
588 {
591 {
593 nGlobalError);
595 }
597 }
598 else
599 {
603 {
607 }
608 else
610 }
611 }
612 }
617 ScRange aRange;
620 {
624 }
625 else
626 {
627 // Do not modify the original range because we use it
628 // to adjust the size of the result matrix if necessary.
636 {
639 }
640 else
641 {
642 // Replicate column and/or row of a vector if it is
643 // one. Note that this could be a range reference
644 // that in fact consists of only one cell, e.g. A1:A1
651 ScRefCellValue aCell;
656 {
659 {
661 nGlobalError);
663 }
665 }
666 else
667 {
671 {
675 }
676 else
678 }
679 }
683 }
684 }
691 {
695 }
697 {
700 }
701 else
702 {
707 {
710 }
711 else
712 {
714 }
716 }
717 }
720 {
725 }
728 {
732 }
733 }
734 }
735 }
738 {
745 {
746 // a false without path results in an empty path value
749 else
751 }
755 }
757 {
760 {
763 {
764 // This is not the current state of the interpreter, so
765 // push without error, and elements' errors are coded into
766 // double.
768 }
769 }
771 }
772 }
779 // Remove jump matrix from map and remember result matrix in case it
780 // could be reused in another path of the same condition.
782 {
786 }
788 }
790 }
793 {
797 {
801 {
817 {
818 ScAddress aAdr;
821 ScRefCellValue aCell;
826 {
831 }
832 else
833 {
836 }
837 }
840 {
843 {
846 }
851 {
854 }
858 {
861 }
862 else
863 {
866 }
867 }
870 // TODO: Find out how to handle this...
874 }
875 }
880 }
884 {
889 ScAddress aAdr;
891 {
895 {
910 {
912 ScRefCellValue aCell;
917 {
922 }
923 else
924 {
927 }
928 }
935 else
937 // errors are transported as DoubleError inside matrix
942 }
943 }
948 {
951 }
954 {
965 {
967 {
971 {
973 {
977 {
981 }
982 else
983 {
987 }
988 }
991 }
992 else
994 }
995 }
998 {
1021 }
1022 }
1024 {
1038 }
1042 }
1046 {
1053 else
1059 {
1062 }
1065 }
1068 {
1070 {
1073 {
1076 }
1079 }
1080 else
1082 }
1086 {
1088 {
1091 {
1094 }
1097 }
1098 else
1100 }
1104 {
1106 {
1109 {
1112 }
1115 }
1116 else
1118 }
1122 {
1124 {
1127 {
1130 }
1133 }
1134 else
1136 }
1140 {
1142 {
1145 {
1148 }
1151 }
1152 else
1154 }
1158 {
1160 {
1163 {
1166 }
1169 }
1170 else
1172 }
1176 {
1180 {
1185 {
1187 {
1189 {
1199 {
1200 ScAddress aAdr;
1203 {
1204 ScRefCellValue aCell;
1207 {
1210 }
1211 // else: Xcl raises no error here
1212 }
1213 }
1217 {
1218 ScRange aRange;
1221 {
1226 {
1228 do
1229 {
1233 }
1235 }
1236 }
1241 {
1244 {
1249 {
1252 }
1253 else
1255 }
1256 // else: GetMatrix did set errIllegalParameter
1257 }
1262 }
1263 }
1264 else
1266 }
1269 else
1271 }
1272 }
1276 {
1280 {
1285 {
1287 {
1289 {
1299 {
1300 ScAddress aAdr;
1303 {
1304 ScRefCellValue aCell;
1307 {
1310 }
1311 // else: Xcl raises no error here
1312 }
1313 }
1317 {
1318 ScRange aRange;
1321 {
1326 {
1328 do
1329 {
1333 }
1335 }
1336 }
1341 {
1345 {
1350 {
1353 }
1354 else
1356 }
1357 // else: GetMatrix did set errIllegalParameter
1358 }
1363 }
1364 }
1365 else
1367 }
1370 else
1372 }
1373 }
1377 {
1382 {
1387 {
1389 {
1391 {
1401 {
1402 ScAddress aAdr;
1405 {
1406 ScRefCellValue aCell;
1409 {
1412 }
1413 /* TODO: set error? Excel doesn't have XOR, but
1414 * doesn't set an error in this case for AND and
1415 * OR. */
1416 }
1417 }
1421 {
1422 ScRange aRange;
1425 {
1430 {
1432 do
1433 {
1437 }
1439 }
1440 }
1445 {
1449 {
1454 {
1457 }
1458 else
1460 }
1461 // else: GetMatrix did set errIllegalParameter
1462 }
1467 }
1468 }
1469 else
1471 }
1474 else
1476 }
1477 }
1481 {
1482 // Simple negation doesn't change current format type to number, keep
1483 // current type.
1486 {
1488 {
1492 else
1493 {
1499 else
1500 {
1502 {
1504 {
1507 else
1510 }
1511 }
1513 }
1514 }
1515 }
1519 }
1520 }
1524 {
1535 }
1539 {
1542 {
1544 {
1548 else
1549 {
1555 else
1556 {
1558 {
1560 {
1563 else
1566 }
1567 }
1569 }
1570 }
1571 }
1575 }
1576 }
1580 {
1590 else
1592 }
1596 {
1606 else
1608 }
1612 {
1622 else
1624 }
1628 {
1637 else
1638 {
1644 else
1647 }
1648 }
1652 {
1661 else
1662 {
1668 else
1671 }
1672 }
1676 {
1678 }
1682 {
1684 }
1688 {
1691 }
1695 {
1698 }
1702 {
1704 }
1708 {
1710 }
1714 {
1716 }
1720 {
1722 }
1726 {
1728 }
1732 {
1734 }
1738 {
1740 }
1744 {
1746 }
1750 {
1752 }
1756 {
1758 }
1762 {
1764 }
1768 {
1770 }
1774 {
1776 }
1780 {
1782 }
1786 {
1788 }
1791 {
1795 else
1797 }
1800 {
1804 else
1806 }
1810 {
1814 else
1816 }
1819 {
1821 }
1824 {
1826 }
1829 {
1831 }
1834 {
1836 }
1840 {
1842 }
1846 {
1850 else
1852 }
1856 {
1860 {
1862 {
1866 }
1870 {
1871 ScAddress aAdr;
1874 // NOTE: this could test also on inherited emptiness, but then the
1875 // cell tested wouldn't be empty. Must correspond with
1876 // ScCountEmptyCells().
1877 ScRefCellValue aCell;
1881 }
1886 {
1892 else
1893 {
1899 // else: false, not empty (which is what Xcl does)
1900 }
1901 }
1905 }
1908 }
1912 {
1916 {
1923 {
1924 ScAddress aAdr;
1928 ScRefCellValue aCell;
1931 {
1933 {
1943 }
1944 }
1945 }
1948 {
1954 else
1955 {
1961 }
1962 }
1966 }
1969 }
1973 {
1975 }
1979 {
1981 }
1985 {
1988 {
1991 {
1992 ScAddress aAdr;
1996 ScRefCellValue aCell;
1999 {
2001 {
2004 }
2005 }
2006 }
2009 // TODO: we don't have type information for arrays except
2010 // numerical/string.
2011 // Fall thru
2016 }
2020 }
2024 {
2027 {
2030 {
2031 ScAddress aAdr;
2035 ScRefCellValue aCell;
2038 {
2040 {
2041 // NOTE: this is Xcl nonsense!
2047 {
2051 else
2053 }
2060 }
2061 }
2062 else
2064 }
2069 {
2072 }
2073 else
2079 {
2082 }
2083 else
2085 // we could return the type of one element if in JumpMatrix or
2086 // ForceArray mode, but Xcl doesn't ...
2091 {
2094 }
2095 else
2097 }
2099 }
2103 {
2105 }
2109 {
2111 }
2116 {
2123 {
2129 {
2132 {
2152 }
2153 }
2154 }
2162 }
2164 }
2170 {
2174 {
2176 {
2179 {
2180 // Let's handle external reference separately...
2183 }
2185 ;
2186 }
2188 }
2192 else
2193 {
2194 ScRefCellValue aCell;
2199 // *** ADDRESS INFO ***
2203 }
2207 }
2211 }
2217 }
2221 OUString aFuncResult;
2223 {
2226 else
2227 {
2230 {
2231 OUStringBuffer aBuf;
2236 OUString aTabName;
2240 }
2241 }
2242 }
2244 }
2247 // Yes, passing tab as col is intentional!
2248 OUStringBuffer aFuncResult;
2249 OUString aCellStr =
2258 }
2260 // *** CELL PROPERTIES ***
2264 {
2268 }
2269 else
2271 }
2274 sal_Unicode c;
2277 else
2280 }
2286 Font aDefFont;
2289 // font color doesn't matter here
2297 }
2302 {
2306 {
2313 }
2314 }
2316 }
2322 }
2324 // *** FORMATTING ***
2327 OUString aFuncResult;
2331 }
2336 }
2341 }
2342 else
2344 }
2345 }
2346 }
2349 {
2350 sal_uInt16 nFileId;
2351 OUString aTabName;
2352 ScSingleRefData aRef;
2357 {
2360 }
2364 {
2367 }
2369 SCCOL nCol;
2370 SCROW nRow;
2371 SCTAB nTab;
2375 {
2378 }
2389 {
2390 // For SHEET, No idea what number we should set, but let's always set
2391 // 1 if the external sheet exists, no matter what sheet. Excel does
2392 // the same.
2395 else
2397 }
2399 {
2400 // ODF 1.2 says we need to always display address using the ODF A1 grammar.
2401 ScTokenArray aArray;
2405 OUString aStr;
2408 }
2410 {
2411 // 'file URI'#$SheetName
2415 {
2416 // In theory this should never happen...
2419 }
2421 OUStringBuffer aBuf;
2427 }
2429 {
2431 {
2443 }
2444 }
2446 {
2449 {
2457 ;
2458 }
2460 }
2462 {
2463 OUString aFmtStr;
2467 }
2469 {
2470 // 1 = negative values are colored, otherwise 0
2473 {
2476 }
2478 }
2480 {
2481 // 1 = format string contains a '(' character, otherwise 0
2484 {
2487 }
2489 }
2490 else
2492 }
2495 {
2499 {
2501 {
2502 ScAddress aAdr;
2506 }
2509 {
2510 ScRange aRange;
2514 }
2517 {
2521 }
2525 }
2528 }
2532 {
2536 {
2543 {
2544 ScAddress aAdr;
2548 ScRefCellValue aCell;
2551 {
2553 {
2562 }
2563 }
2564 }
2567 {
2572 {
2575 }
2576 else
2577 {
2584 }
2585 }
2589 }
2592 }
2596 {
2600 {
2603 {
2604 ScAddress aAdr;
2609 }
2613 }
2616 }
2620 {
2621 OUString aFormula;
2623 {
2626 {
2627 ScAddress aAdr;
2631 ScRefCellValue aCell;
2634 {
2640 }
2641 }
2646 }
2648 }
2653 {
2657 {
2660 {
2661 ScAddress aAdr;
2665 else
2666 {
2667 ScRefCellValue aCell;
2671 }
2672 }
2675 {
2681 else
2682 {
2688 }
2689 }
2695 }
2698 }
2702 {
2706 {
2709 {
2710 ScAddress aAdr;
2714 else
2715 {
2716 ScRefCellValue aCell;
2720 }
2721 }
2724 {
2729 {
2732 }
2733 else
2734 {
2739 {
2742 }
2743 }
2744 }
2750 }
2753 }
2757 {
2761 {
2764 {
2765 ScAddress aAdr;
2767 {
2770 }
2773 else
2774 {
2775 ScRefCellValue aCell;
2778 }
2779 }
2782 {
2788 else
2789 {
2795 }
2796 }
2802 }
2805 }
2809 {
2814 {
2817 {
2818 ScAddress aAdr;
2822 ScRefCellValue aCell;
2827 else
2828 {
2830 {
2837 {
2840 }
2844 }
2845 }
2846 }
2849 {
2852 }
2855 {
2860 {
2864 }
2865 else
2866 {
2871 {
2875 }
2876 else
2878 }
2879 }
2883 }
2886 else
2889 }
2893 {
2895 }
2899 {
2901 }
2904 {
2907 // Temporarily override the ConvertStringToValue() error for
2908 // GetCellValue() / GetCellValueOrZero()
2918 }
2921 {
2922 // Doesn't only trim but also removes duplicated blanks within!
2924 OUStringBuffer aStr;
2928 {
2931 p++;
2932 }
2934 }
2938 {
2941 }
2945 {
2946 //2do: what to do with I18N-CJK ?!?
2950 {
2956 {
2960 else
2963 }
2964 }
2966 }
2970 {
2973 }
2977 {
2979 }
2983 {
2985 {
2988 {
2989 ScAddress aAdr;
2991 {
2994 }
2996 ScRefCellValue aCell;
2999 {
3001 {
3010 }
3011 }
3014 else
3015 {
3016 // like GetString()
3020 }
3021 }
3026 {
3032 else
3034 }
3037 {
3040 }
3047 }
3048 }
3052 {
3053 OUString aInputString;
3057 {
3065 //break;
3069 {
3070 ScAddress aAdr;
3072 {
3075 }
3076 ScRefCellValue aCell;
3079 {
3083 }
3085 {
3088 }
3089 else
3090 {
3093 }
3094 }
3097 {
3100 aSS);
3103 {
3106 // fallthru
3111 //break;
3113 // evaluated below
3117 }
3118 }
3123 }
3128 else
3130 }
3133 // fdo#57180
3135 {
3141 OUString aInputString;
3149 {
3153 else
3154 {
3157 }
3158 }
3161 {
3164 }
3167 {
3172 }
3174 {
3177 }
3179 {
3182 else
3185 }
3189 {
3193 {
3196 }
3199 else
3201 }
3204 {
3208 }
3211 {
3213 nPercentCount++;
3214 }
3216 rtl_math_ConversionStatus eStatus;
3217 sal_Int32 nParseEnd;
3218 double fVal = ::rtl::math::stringToDouble( aInputString, cDecimalSeparator, 0, &eStatus, &nParseEnd );
3220 {
3225 }
3227 }
3230 //2do: this should be a proper unicode string method
3232 {
3234 }
3237 {
3240 {
3243 }
3245 }
3249 {
3250 //2do: make it full range unicode?
3252 //"classic" ByteString conversion flags
3254 RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE |
3255 RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE |
3256 RTL_UNICODETOTEXT_FLAGS_FLUSH |
3257 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |
3258 RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT |
3259 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE;
3260 PushInt( (sal_uChar) OUStringToOString(OUString(aStr[0]), osl_getThreadTextEncoding(), convertFlags).toChar() );
3261 }
3265 {
3266 //2do: make it full range unicode?
3270 else
3271 {
3272 //"classic" ByteString conversion flags
3274 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT |
3275 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
3276 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT;
3281 }
3282 }
3285 /* #i70213# fullwidth/halfwidth conversion provided by
3286 * Takashi Nakamoto <bluedwarf@ooo>
3287 * erAck: added Excel compatibility conversions as seen in issue's test case. */
3290 {
3295 {
3298 }
3301 }
3305 {
3310 {
3313 }
3316 }
3319 /* ODFF:
3320 * Summary: Converts half-width to full-width ASCII and katakana characters.
3321 * Semantics: Conversion is done for half-width ASCII and katakana characters,
3322 * other characters are simply copied from T to the result. This is the
3323 * complementary function to ASC.
3324 * For references regarding halfwidth and fullwidth characters see
3325 * http://www.unicode.org/reports/tr11/
3326 * http://www.unicode.org/charts/charindex2.html#H
3327 * http://www.unicode.org/charts/charindex2.html#F
3328 */
3330 {
3333 }
3336 /* ODFF:
3337 * Summary: Converts full-width to half-width ASCII and katakana characters.
3338 * Semantics: Conversion is done for full-width ASCII and katakana characters,
3339 * other characters are simply copied from T to the result. This is the
3340 * complementary function to JIS.
3341 */
3343 {
3346 }
3349 {
3351 {
3355 else
3356 {
3359 }
3360 }
3361 }
3364 {
3366 {
3370 else
3371 {
3375 }
3376 }
3377 }
3381 {
3387 ScAddress aAdr;
3388 ScRange aRange;
3391 {
3393 {
3395 {
3399 }
3402 {
3404 ScRefCellValue aCell;
3407 {
3411 }
3413 {
3416 }
3417 }
3421 {
3426 {
3431 {
3434 }
3436 }
3437 }
3442 {
3445 {
3450 }
3451 }
3454 {
3457 {
3460 }
3461 else
3463 }
3468 }
3469 }
3472 else
3474 }
3477 {
3483 ScAddress aAdr;
3484 ScRange aRange;
3487 {
3489 {
3491 {
3495 }
3498 {
3500 ScRefCellValue aCell;
3503 {
3507 }
3509 {
3512 }
3513 }
3517 {
3522 {
3527 {
3530 }
3532 }
3533 }
3538 {
3541 {
3546 }
3547 }
3550 {
3553 {
3556 }
3557 else
3559 }
3564 }
3565 }
3568 else
3570 }
3574 {
3583 ScAddress aAdr;
3584 ScRange aRange;
3587 {
3589 {
3591 {
3595 rValCount++;
3596 }
3599 {
3601 ScRefCellValue aCell;
3604 {
3608 rValCount++;
3609 }
3611 {
3613 rValCount++;
3614 }
3615 }
3619 {
3624 {
3625 do
3626 {
3629 rValCount++;
3630 }
3632 }
3633 }
3636 {
3639 {
3643 {
3645 {
3647 {
3651 rValCount++;
3652 }
3654 {
3656 rValCount++;
3657 }
3658 }
3659 }
3660 }
3661 }
3664 {
3667 {
3669 rValCount++;
3670 }
3671 else
3673 }
3678 }
3679 }
3686 }
3690 {
3697 else
3699 }
3703 {
3709 }
3713 {
3719 else
3721 }
3725 {
3731 else
3734 /* this was: PushDouble( sqrt( div( nVal, nValCount)));
3735 *
3736 * Besides that the special NAN gets lost in the call through sqrt(),
3737 * unxlngi6.pro then looped back and forth somewhere between div() and
3738 * ::rtl::math::setNan(). Tests showed that
3739 *
3740 * sqrt( div( 1, 0));
3741 *
3742 * produced a loop, but
3743 *
3744 * double f1 = div( 1, 0);
3745 * sqrt( f1 );
3746 *
3747 * was fine. There seems to be some compiler optimization problem. It does
3748 * not occur when compiled with debug=t.
3749 */
3750 }
3754 {
3757 SCCOL nCol1;
3758 SCROW nRow1;
3759 SCTAB nTab1;
3760 SCCOL nCol2;
3761 SCROW nRow2;
3762 SCTAB nTab2;
3764 {
3766 {
3769 nVal++;
3777 {
3780 {
3784 }
3785 }
3789 nVal++;
3792 {
3793 sal_uInt16 nFileId;
3794 OUString aTabName;
3795 ScComplexRefData aRef;
3800 }
3805 }
3806 }
3808 }
3812 {
3815 SCCOL nCol1;
3816 SCROW nRow1;
3817 SCTAB nTab1;
3818 SCCOL nCol2;
3819 SCROW nRow2;
3820 SCTAB nTab2;
3822 {
3824 {
3827 nVal++;
3835 {
3838 {
3842 }
3843 }
3847 nVal++;
3850 {
3851 sal_uInt16 nFileId;
3852 OUString aTabName;
3853 ScComplexRefData aRef;
3858 }
3863 }
3864 }
3866 }
3869 {
3871 sal_uLong nVal;
3874 else
3875 {
3877 SCCOL nCol1;
3878 SCROW nRow1;
3879 SCTAB nTab1;
3880 SCCOL nCol2;
3881 SCROW nRow2;
3882 SCTAB nTab2;
3884 {
3886 {
3889 nVal++;
3897 nVal++;
3901 nVal++;
3904 {
3905 sal_uInt16 nFileId;
3906 OUString aTabName;
3907 ScComplexRefData aRef;
3911 }
3916 }
3917 }
3918 }
3920 }
3924 {
3927 {
3930 {
3933 {
3934 SCCOL nCols;
3935 SCROW nRows;
3938 {
3939 // Happens if called via ScViewFunc::EnterMatrix()
3940 // ScFormulaCell::GetResultDimensions() as of course a
3941 // matrix result is not available yet.
3943 }
3946 {
3951 }
3952 }
3953 }
3954 else
3955 {
3957 {
3959 {
3960 SCCOL nCol1;
3961 SCROW nRow1;
3962 SCTAB nTab1;
3965 }
3968 {
3969 SCCOL nCol1;
3970 SCROW nRow1;
3971 SCTAB nTab1;
3972 SCCOL nCol2;
3973 SCROW nRow2;
3974 SCTAB nTab2;
3977 {
3981 {
3987 }
3988 else
3990 }
3991 else
3993 }
3998 }
3999 }
4001 }
4002 }
4006 {
4009 {
4012 {
4015 {
4016 SCCOL nCols;
4017 SCROW nRows;
4020 {
4021 // Happens if called via ScViewFunc::EnterMatrix()
4022 // ScFormulaCell::GetResultDimensions() as of course a
4023 // matrix result is not available yet.
4025 }
4028 {
4033 }
4034 }
4035 }
4036 else
4037 {
4039 {
4041 {
4042 SCCOL nCol1;
4043 SCROW nRow1;
4044 SCTAB nTab1;
4047 }
4050 {
4051 SCCOL nCol1;
4052 SCROW nRow1;
4053 SCTAB nTab1;
4054 SCCOL nCol2;
4055 SCROW nRow2;
4056 SCTAB nTab2;
4059 {
4063 {
4069 }
4070 else
4072 }
4073 else
4075 }
4080 }
4081 }
4083 }
4084 }
4087 {
4090 {
4094 else
4095 {
4097 {
4099 {
4103 else
4105 }
4108 {
4109 SCCOL nCol1;
4110 SCROW nRow1;
4111 SCTAB nTab1;
4114 }
4117 {
4118 SCCOL nCol1;
4119 SCROW nRow1;
4120 SCTAB nTab1;
4121 SCCOL nCol2;
4122 SCROW nRow2;
4123 SCTAB nTab2;
4126 }
4130 }
4133 }
4135 }
4136 }
4140 class VectorMatrixAccessor
4141 {
4147 {
4149 }
4152 {
4154 }
4157 {
4159 }
4162 {
4164 }
4167 {
4169 }
4172 {
4174 }
4177 {
4181 }
4186 };
4188 /** returns -1 when the matrix value is smaller than the query value, 0 when
4189 they are equal, and 1 when the matrix value is larger than the query
4190 value. */
4193 {
4195 {
4196 /* TODO: in case we introduced query for real empty this would have to
4197 * be changed! */
4199 }
4201 /* FIXME: what is an empty path (result of IF(false;true_path) in
4202 * comparisons? */
4206 {
4216 }
4225 }
4227 /** returns the last item with the identical value as the original item
4228 value. */
4231 {
4233 {
4239 else
4243 }
4244 //! Order of IsEmptyPath, IsEmpty, IsString is significant!
4246 {
4250 else
4253 }
4255 {
4259 else
4262 }
4264 {
4270 else
4274 }
4275 else
4276 {
4278 }
4279 }
4281 }
4284 {
4288 {
4292 else
4303 {
4311 {
4314 {
4317 }
4318 }
4322 {
4325 else
4329 {
4332 }
4333 }
4338 }
4341 {
4343 ScQueryParam rParam;
4357 {
4359 {
4363 }
4366 {
4369 }
4373 {
4374 ScAddress aAdr;
4376 {
4379 }
4380 ScRefCellValue aCell;
4383 {
4387 }
4388 else
4389 {
4392 }
4393 }
4396 {
4400 {
4403 }
4405 {
4408 }
4409 else
4410 {
4413 }
4414 }
4417 // TODO: Implement this.
4422 {
4429 }
4432 {
4435 }
4436 }
4438 {
4443 // #TODO handle MSO wildcards
4446 else
4448 }
4451 {
4455 {
4456 // The source matrix must be a vector.
4459 }
4463 // simple serial search for equality mode (source data doesn't
4464 // need to be sorted).
4467 {
4469 {
4471 {
4474 }
4475 }
4478 }
4480 // binary search for non-equality mode (the source data is
4481 // assumed to be sorted).
4486 {
4490 {
4491 // exact match. find the last item with the same value.
4495 }
4498 {
4501 else
4504 }
4507 {
4510 else
4512 }
4513 else
4514 {
4517 else
4519 }
4520 }
4523 {
4526 {
4527 // either the last item is an exact match or the real
4528 // hit is beyond the last item.
4531 }
4532 }
4535 {
4538 }
4542 }
4551 {
4554 }
4556 }
4557 else
4559 SCCOL nC;
4564 // Advance Entry.nField in Iterator if column changed
4570 else
4571 {
4574 }
4575 }
4576 else
4578 SCROW nR;
4580 {
4583 }
4584 }
4586 }
4588 }
4589 else
4591 }
4592 }
4596 {
4598 {
4600 CellType eCellType;
4602 {
4604 {
4606 ScAddress aAdr;
4611 }
4615 {
4616 ScRange aRange;
4620 {
4622 nMaxCount +=
4629 {
4632 }
4633 }
4634 }
4637 }
4639 }
4640 }
4644 {
4653 ScMatrixRef pSumExtraMatrix;
4656 {
4657 // Save only the upperleft cell in case of cell range. The geometry
4658 // of the 3rd parameter is taken from the 1st parameter.
4661 {
4663 {
4669 {
4672 }
4673 }
4680 //! nCol3, nRow3, nTab3 remain 0
4683 {
4688 {
4691 }
4695 else
4697 }
4705 }
4706 }
4712 {
4715 {
4716 ScAddress aAdr;
4720 ScRefCellValue aCell;
4723 {
4730 {
4733 }
4734 else
4744 }
4745 }
4752 {
4755 }
4758 {
4762 {
4764 {
4767 }
4768 else
4770 }
4771 }
4774 {
4777 }
4778 }
4788 {
4795 ScMatrixRef pQueryMatrix;
4797 {
4800 {
4802 }
4803 else
4804 {
4805 ScRange aRange;
4808 }
4822 {
4825 {
4828 }
4837 }
4841 }
4843 {
4845 }
4848 {
4849 // Take the range geometry of the 1st parameter and apply it to
4850 // the 3rd. If parts of the resulting range would point outside
4851 // the sheet, don't complain but silently ignore and simply cut
4852 // them away, this is what Xcl does :-/
4854 // For the cut-away part we also don't need to determine the
4855 // criteria match, so shrink the source range accordingly,
4856 // instead of the result range.
4859 SCCOL nMaxCol;
4860 SCROW nMaxRow;
4862 {
4867 }
4868 else
4869 {
4872 }
4874 {
4877 }
4880 {
4883 }
4884 }
4885 else
4886 {
4890 }
4893 {
4894 ScQueryParam rParam;
4902 {
4906 }
4907 else
4908 {
4916 }
4917 ScAddress aAdr;
4925 {
4926 // Never case-sensitive.
4930 {
4932 }
4935 {
4937 {
4939 {
4942 {
4946 {
4950 {
4953 }
4954 else
4956 }
4957 }
4958 }
4959 }
4960 }
4961 else
4962 {
4964 {
4966 {
4968 {
4971 ScRefCellValue aCell;
4974 {
4978 {
4981 }
4982 else
4984 }
4985 }
4986 }
4987 }
4988 }
4989 }
4990 else
4991 {
4993 // Increment Entry.nField in iterator when switching to next column.
4996 {
4998 {
4999 do
5000 {
5004 {
5008 {
5011 }
5012 else
5014 }
5016 }
5017 else
5018 {
5019 do
5020 {
5023 ScRefCellValue aCell;
5026 {
5030 {
5033 }
5034 else
5036 }
5038 }
5039 }
5040 }
5041 }
5042 else
5043 {
5046 }
5047 }
5050 {
5053 }
5055 }
5058 {
5060 }
5063 {
5065 }
5068 {
5070 {
5075 {
5078 {
5079 ScAddress aAdr;
5081 {
5084 }
5085 ScRefCellValue aCell;
5088 {
5095 {
5098 }
5099 else
5109 }
5110 }
5115 {
5118 }
5124 {
5127 }
5128 }
5133 {
5140 ScMatrixRef pQueryMatrix;
5142 {
5145 {
5146 ScRange aRange;
5149 }
5160 {
5163 {
5166 }
5175 }
5180 }
5182 {
5185 }
5187 {
5190 }
5192 {
5193 ScQueryParam rParam;
5201 {
5205 }
5206 else
5207 {
5215 }
5220 {
5221 // Never case-sensitive.
5225 {
5228 }
5232 {
5236 }
5237 }
5238 else
5239 {
5241 // Keep Entry.nField in iterator on column change
5244 {
5245 do
5246 {
5247 fCount++;
5249 }
5250 }
5251 }
5252 else
5253 {
5256 }
5257 }
5259 }
5260 }
5263 {
5270 else
5274 {
5276 }
5277 else
5278 {
5293 {
5294 // take criteria
5299 {
5302 {
5303 ScAddress aAdr;
5307 ScRefCellValue aCell;
5310 {
5317 {
5320 }
5321 else
5331 }
5332 }
5339 {
5342 }
5345 {
5349 {
5351 {
5354 }
5355 else
5357 }
5358 }
5361 {
5364 }
5365 }
5370 // take range
5379 ScMatrixRef pQueryMatrix;
5381 {
5383 {
5384 ScRange aRange;
5387 }
5401 {
5404 {
5407 }
5416 }
5421 }
5423 {
5426 }
5428 // All reference ranges must be of same dimension and size.
5434 {
5437 }
5439 // recalculate matrix values
5443 // initialize temporary result matrix
5445 {
5449 }
5451 ScQueryParam rParam;
5459 {
5463 }
5464 else
5465 {
5473 }
5474 ScAddress aAdr;
5482 {
5483 // Never case-sensitive.
5487 {
5490 }
5492 // result matrix is filled with boolean values.
5496 {
5499 }
5505 }
5506 else
5507 {
5509 // Increment Entry.nField in iterator when switching to next column.
5512 {
5513 do
5514 {
5519 }
5520 }
5522 }
5527 // main range - only for AVERAGEIFS and SUMIFS
5529 {
5539 ScMatrixRef pMainMatrix;
5541 {
5543 {
5544 ScRange aRange;
5547 }
5561 {
5564 {
5566 }
5575 }
5580 }
5582 {
5585 }
5587 // All reference ranges must be of same dimension and size.
5588 if ((nDimensionCols != (nMainCol2 - nMainCol1 + 1)) || (nDimensionRows != (nMainRow2 - nMainRow1 + 1)))
5589 {
5592 }
5597 // end-result calculation
5598 ScAddress aAdr;
5601 {
5605 {
5608 }
5613 {
5623 {
5626 }
5627 else
5629 }
5630 }
5631 else
5632 {
5635 {
5637 {
5639 {
5642 ScRefCellValue aCell;
5645 {
5649 {
5652 }
5653 else
5655 }
5656 }
5657 }
5658 }
5659 }
5660 }
5661 else
5662 {
5667 }
5670 {
5675 }
5677 }
5679 }
5682 {
5684 }
5687 {
5689 }
5692 {
5694 }
5697 {
5709 // The third parameter, result array, for double, string and single reference.
5712 ScAddress aResAdr;
5716 {
5719 {
5721 {
5722 SCTAB nTabJunk;
5727 {
5728 // The result array must be a vector.
5731 }
5732 }
5737 {
5740 {
5743 }
5747 {
5748 // Result matrix must be a vector.
5751 }
5752 }
5766 }
5767 }
5769 // For double, string and single reference.
5772 ScAddress aDataAdr;
5775 // Get the data-result range and also determine whether this is vertical
5776 // lookup or horizontal lookup.
5780 {
5782 {
5783 SCTAB nTabJunk;
5786 {
5789 }
5792 }
5797 {
5800 {
5803 }
5809 }
5812 {
5815 }
5818 {
5820 }
5823 {
5825 ScRefCellValue aCell;
5828 {
5829 // Empty cells aren't found anywhere, bail out early.
5831 }
5833 {
5836 }
5837 else
5839 }
5843 }
5847 {
5850 }
5852 // Get the lookup value.
5854 ScQueryParam aParam;
5861 {
5862 // Delta position for a single value is always 0.
5864 // Found if data <= query, but not if query is string and found data is
5865 // numeric or vice versa. This is how Excel does it but doesn't
5866 // document it.
5872 {
5875 else
5877 }
5878 else
5879 {
5882 else
5883 bFound = (ScGlobal::GetCollator()->compareString(aDataStr.getString(), rItem.maString.getString()) <= 0);
5884 }
5887 {
5890 }
5893 {
5896 else
5898 }
5900 {
5902 {
5911 // fallthru
5917 }
5918 }
5919 else
5920 {
5922 {
5934 }
5935 }
5937 }
5939 // Now, perform the search to compute the delta position (nDelta).
5942 {
5943 // Data array is given as a matrix.
5951 // In case of non-vector matrix, only search the first row or column.
5952 ScMatrixRef pDataMat2;
5954 {
5959 else
5962 }
5963 else
5964 {
5969 else
5972 }
5976 // binary search for non-equality mode (the source data is
5977 // assumed to be sorted in ascending order).
5983 {
5987 {
5988 // exact match. find the last item with the same value.
5993 }
5996 {
5998 // If already the 1st item is greater there's nothing found.
6001 }
6005 else
6007 }
6010 {
6013 {
6014 // either the last item is an exact match or the real
6015 // hit is beyond the last item.
6018 }
6019 }
6021 {
6022 // non-exact match
6024 }
6026 // With 0-9 < A-Z, if query is numeric and data found is string, or
6027 // vice versa, the (yet another undocumented) Excel behavior is to
6028 // return #N/A instead.
6031 {
6040 }
6043 {
6046 }
6048 // Now that we've found the delta, push the result back to the cell.
6051 {
6053 // result array is matrix.
6055 {
6058 }
6061 else
6063 }
6065 {
6066 // result array is cell range.
6067 ScAddress aAdr;
6071 {
6074 {
6077 }
6080 }
6081 else
6082 {
6085 {
6088 }
6091 }
6093 }
6094 else
6095 {
6096 // no result array. Use the data array to get the final value from.
6098 {
6101 else
6103 }
6104 else
6105 {
6108 else
6110 }
6111 }
6114 }
6116 // Perform cell range search.
6132 SCCOL nC;
6133 SCROW nR;
6134 // Advance Entry.nField in iterator upon switching columns if
6135 // lookup in row.
6138 {
6141 }
6146 {
6148 // Use the matrix result array.
6151 else
6153 }
6155 {
6157 {
6159 {
6160 // Use the result array vector. Note that the result array is assumed
6161 // to be a vector (i.e. 1-dimensinoal array).
6163 ScAddress aAdr;
6167 {
6170 {
6173 }
6176 }
6177 else
6178 {
6181 {
6184 }
6187 }
6189 }
6194 {
6197 else
6198 {
6200 {
6212 }
6213 }
6214 }
6218 }
6219 }
6220 else
6221 {
6222 // Regardless of whether or not the result array exists, the last
6223 // array is always used as the "result" array.
6225 ScAddress aAdr;
6228 {
6231 {
6234 }
6237 }
6238 else
6239 {
6242 {
6245 }
6248 }
6250 }
6251 }
6255 {
6257 }
6260 {
6265 // Optional 4th argument to declare whether or not the range is sorted.
6270 // Index of column to search.
6280 SCTAB nTab2;
6283 {
6286 {
6289 }
6290 }
6292 {
6296 }
6298 {
6303 else
6304 {
6307 }
6308 }
6309 else
6310 {
6313 }
6315 if ( fIndex < 0.0 || (bHLookup ? (pMat ? (fIndex >= nR) : (fIndex+nRow1 > nRow2)) : (pMat ? (fIndex >= nC) : (fIndex+nCol1 > nCol2)) ) )
6316 {
6319 }
6325 {
6328 }
6331 {
6334 }
6336 ScQueryParam aParam;
6340 {
6344 }
6345 else
6346 {
6350 }
6363 {
6367 {
6368 //!!!!!!!
6369 //! TODO: enable regex on matrix strings
6370 //!!!!!!!
6373 {
6376 {
6378 {
6379 sal_Int32 nRes =
6381 bHLookup ? pMat->GetString(i,0).getString() : pMat->GetString(0,i).getString(), aParamStr.getString());
6386 }
6387 else
6389 }
6390 }
6391 else
6392 {
6394 {
6396 {
6398 {
6400 {
6403 }
6404 }
6405 }
6406 }
6407 else
6408 {
6410 }
6411 }
6412 }
6413 else
6414 {
6416 {
6417 // #i2168# ignore strings
6419 {
6421 {
6424 else
6426 }
6427 }
6428 }
6429 else
6430 {
6432 {
6434 {
6436 {
6438 {
6441 }
6442 }
6443 }
6444 }
6445 else
6446 {
6448 }
6449 }
6450 }
6452 {
6456 {
6459 }
6462 else
6464 }
6465 else
6467 }
6468 else
6469 {
6477 {
6479 // advance Entry.nField in Iterator upon switching columns
6482 {
6483 SCROW nRow1_temp;
6485 }
6487 {
6490 }
6492 }
6493 else
6494 {
6499 }
6502 {
6505 }
6506 else
6508 }
6509 }
6512 {
6515 {
6517 {
6520 }
6523 {
6526 }
6530 {
6531 ScAddress aAdr;
6533 {
6536 }
6537 ScRefCellValue aCell;
6540 {
6543 }
6544 else
6545 {
6548 }
6549 }
6552 {
6558 }
6561 {
6564 }
6567 }
6569 {
6571 }
6574 {
6577 {
6578 // We must fish the 1st parameter deep from the stack! And push it on top.
6584 {
6585 // For opcodes 101 through 111, we need to skip hidden cells.
6586 // Other than that these opcodes are identical to 1 through 11.
6589 }
6593 else
6594 {
6595 // TODO: Make use of bIncludeHidden flag. Then it's false, we do need to skip hidden cells.
6599 {
6612 }
6614 }
6615 // Get rid of the 1st (fished) parameter.
6619 }
6620 }
6623 {
6626 {
6629 }
6631 {
6632 // First, get the query criteria range.
6633 SAL_WNODEPRECATED_DECLARATIONS_PUSH
6635 SAL_WNODEPRECATED_DECLARATIONS_POP
6642 ScRange aMissingRange;
6645 {
6656 {
6657 ScAddress aAdr;
6659 ScRefCellValue aCell;
6663 else
6664 {
6667 }
6668 }
6675 }
6676 else
6677 {
6680 }
6686 else
6692 }
6697 SAL_WNODEPRECATED_DECLARATIONS_PUSH
6699 SAL_WNODEPRECATED_DECLARATIONS_POP
6705 {
6706 // range parameter must match entire database range
6709 else
6711 }
6721 else
6722 {
6726 }
6731 SAL_WNODEPRECATED_DECLARATIONS_PUSH
6733 SAL_WNODEPRECATED_DECLARATIONS_POP
6736 {
6737 // An allowed missing field parameter sets the result field
6738 // to any of the query fields, just to be able to return
6739 // some cell from the iterator.
6746 {
6760 }
6762 }
6763 }
6765 }
6769 {
6775 SAL_WNODEPRECATED_DECLARATIONS_PUSH
6777 SAL_WNODEPRECATED_DECLARATIONS_POP
6779 {
6781 {
6784 }
6788 {
6790 {
6795 }
6796 do
6797 {
6798 nCount++;
6800 {
6804 {
6807 }
6808 else
6816 }
6817 }
6819 }
6821 }
6822 else
6825 {
6830 }
6832 }
6836 {
6838 }
6842 {
6844 SAL_WNODEPRECATED_DECLARATIONS_PUSH
6846 SAL_WNODEPRECATED_DECLARATIONS_POP
6848 {
6852 // TODO: currently the QueryIterators only return cell pointers of
6853 // existing cells, so if a query matches an empty cell there's
6854 // nothing returned, and therefor not counted!
6855 // Since this has ever been the case and this code here only came
6856 // into existance to fix #i6899 and it never worked before we'll
6857 // have to live with it until we reimplement the iterators to also
6858 // return empty cells, which would mean to adapt all callers of
6859 // iterators.
6863 // ScQueryCellIterator doesn't make use of ScDBQueryParamBase::mnField,
6864 // so the source range has to be restricted, like before the introduction
6865 // of ScDBQueryParamBase.
6869 {
6870 do
6871 {
6872 nCount++;
6874 }
6875 }
6876 else
6879 {
6882 }
6886 {
6887 do
6888 {
6889 nCount++;
6890 }
6892 }
6894 }
6896 }
6897 else
6899 }
6903 {
6905 SAL_WNODEPRECATED_DECLARATIONS_PUSH
6907 SAL_WNODEPRECATED_DECLARATIONS_POP
6909 {
6911 {
6914 }
6920 {
6921 do
6922 {
6923 nCount++;
6924 }
6926 }
6929 }
6930 else
6932 }
6936 {
6938 }
6942 {
6944 }
6948 {
6950 }
6954 {
6956 }
6960 {
6968 SAL_WNODEPRECATED_DECLARATIONS_PUSH
6970 SAL_WNODEPRECATED_DECLARATIONS_POP
6972 {
6974 {
6977 }
6981 {
6982 do
6983 {
6984 rValCount++;
6987 }
6989 }
6991 }
6992 else
7001 }
7005 {
7009 }
7013 {
7017 }
7021 {
7025 }
7029 {
7033 }
7036 {
7039 {
7040 // Reference address syntax for INDIRECT is configurable.
7043 // Use the current address syntax if unspecified.
7047 {
7048 // Overwrite the config and try Excel R1C1.
7050 }
7057 {
7059 {
7064 }
7065 else
7068 }
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 }
7111 }
7112 }
7113 }
7117 {
7118 OUString sTabStr;
7133 {
7136 {
7149 }
7150 }
7156 {
7157 // YUCK! The XL interface actually treats rel R1C1 refs differently
7158 // than A1
7163 }
7168 {
7171 }
7178 {
7179 OUString aDoc;
7181 {
7182 // Isolate Tab from 'Doc'#Tab
7185 {
7190 }
7191 }
7192 /* TODO: yet unsupported external reference in CONV_XL_R1C1 syntax may
7193 * need some extra handling to isolate Tab from Doc. */
7201 }
7202 else
7204 }
7208 {
7211 {
7226 {
7229 }
7231 {
7233 {
7236 {
7241 else
7243 }
7244 else
7245 {
7257 else
7259 }
7261 }
7263 {
7264 sal_uInt16 nFileId;
7265 OUString aTabName;
7266 ScSingleRefData aRef;
7274 {
7279 else
7281 }
7282 else
7283 {
7296 else
7298 }
7300 }
7302 {
7315 else
7318 }
7320 {
7321 sal_uInt16 nFileId;
7322 OUString aTabName;
7323 ScComplexRefData aRef;
7343 else
7346 }
7351 }
7352 }
7356 {
7359 {
7362 SCCOL nCol;
7363 SCROW nRow;
7366 else
7370 else
7374 else
7378 else
7381 {
7384 }
7386 {
7389 }
7391 {
7395 {
7401 {
7404 // Access one element of a vector independent of col/row
7405 // orientation?
7417 {
7421 else
7423 }
7425 {
7428 {
7434 else
7438 }
7439 else
7441 }
7443 {
7446 {
7452 else
7455 }
7456 else
7458 }
7459 else
7460 {
7466 else
7470 }
7471 }
7472 }
7475 {
7482 else
7484 }
7488 {
7497 {
7500 {
7503 }
7509 }
7510 else
7511 {
7515 }
7522 {
7525 else
7527 }
7529 {
7532 else
7535 }
7537 {
7541 {
7545 }
7546 else
7549 }
7550 else
7552 }
7556 }
7557 }
7558 }
7562 {
7563 // Legacy support, convert to RefList
7566 {
7568 {
7570 }
7571 }
7572 }
7576 {
7579 {
7582 {
7584 {
7588 }
7591 {
7595 }
7598 {
7602 }
7606 }
7608 }
7609 }
7613 {
7616 {
7617 OUString aStr;
7620 {
7623 {
7626 }
7627 }
7628 else
7634 else
7638 else
7644 NUMBERFORMAT_CURRENCY,
7647 {
7649 nIndex,
7656 fVal,
7657 aStr,
7661 }
7662 else
7663 {
7665 }
7667 }
7668 }
7672 {
7674 {
7682 else
7683 {
7695 }
7696 }
7697 }
7701 {
7704 {
7705 OUString aStr;
7710 else
7713 {
7716 {
7719 }
7720 }
7721 else
7727 else
7731 else
7737 NUMBERFORMAT_NUMBER,
7740 nIndex,
7747 fVal,
7748 aStr,
7752 else
7754 }
7755 }
7759 {
7762 {
7766 else
7771 else
7772 {
7776 else
7778 }
7779 }
7780 }
7784 {
7787 {
7791 }
7792 }
7796 {
7799 {
7800 sal_Int32 n;
7802 {
7805 {
7808 }
7809 else
7811 }
7812 else
7818 }
7819 }
7822 UBlockCode from;
7823 UBlockCode to;
7835 };
7836 #define scriptListCount sizeof (scriptList) / sizeof (UBlockScript)
7838 {
7839 // for the locale of ja-JP, character U+0x005c and U+0x20ac should be ScriptType::Asian
7843 sal_uInt16 i;
7848 }
7851 }
7853 {
7855 }
7857 {
7865 else
7866 length++;
7867 index++;
7868 }
7870 }
7872 {
7874 }
7876 {
7878 {
7882 {
7884 {
7887 }
7889 {
7893 }
7896 else
7897 n--;
7898 }
7900 }
7902 }
7904 {
7907 {
7908 sal_Int32 n;
7910 {
7913 {
7916 }
7917 else
7919 }
7920 else
7924 }
7925 }
7927 {
7929 {
7933 {
7935 {
7938 }
7940 {
7944 }
7947 else
7948 n--;
7949 }
7951 }
7953 }
7955 {
7958 {
7959 sal_Int32 n;
7961 {
7964 {
7967 }
7968 else
7970 }
7971 else
7975 }
7976 }
7978 {
7980 {
7984 if (fAnfang < 1.0 || fAnz < 0.0 || fAnfang > double(STRING_MAXLEN) || fAnz > double(STRING_MAXLEN))
7986 else
7987 {
7993 }
7994 }
7995 }
7998 {
8001 {
8002 sal_Int32 n;
8004 {
8007 {
8010 }
8011 else
8013 }
8014 else
8020 }
8021 }
8025 {
8028 {
8031 {
8034 {
8037 }
8038 }
8039 else
8047 else
8048 {
8057 else
8059 }
8060 }
8061 }
8064 {
8066 {
8070 if (fAnfang < 1.0 || fAnz < 0.0 || fAnfang > double(STRING_MAXLEN) || fAnz > double(STRING_MAXLEN))
8072 else
8073 {
8074 sal_Int32 nCharacters = std::min<sal_Int32>(static_cast<sal_Int32>(fAnz), aStr.getLength() - fAnfang + 1);
8075 OUString sRes;
8079 }
8080 }
8081 }
8084 {
8086 {
8092 {
8100 {
8103 {
8105 // Temporarily override the ConvertStringToValue()
8106 // error for GetCellValue() / GetCellValueOrZero()
8112 {
8113 // Not numeric.
8118 }
8119 }
8120 }
8121 }
8124 else
8125 {
8126 OUString aResult;
8128 LanguageType eCellLang;
8134 else
8137 {
8141 else
8143 }
8144 else
8145 {
8149 else
8151 }
8152 }
8153 }
8154 }
8158 {
8161 {
8162 sal_Int32 nAnz;
8164 {
8167 {
8170 }
8171 else
8173 }
8174 else
8184 {
8187 {
8188 nCount++;
8190 {
8193 {
8196 }
8197 else
8199 }
8200 else
8201 nPos++;
8202 }
8203 else
8205 }
8207 }
8208 }
8212 {
8214 {
8220 {
8222 }
8225 else
8226 {
8233 }
8234 }
8235 }
8239 {
8241 OUString aRes;
8243 {
8246 }
8248 }
8252 {
8253 sal_uInt16 nErr;
8257 {
8259 {
8263 else
8264 {
8271 else
8272 {
8273 ScRange aRange;
8277 else
8278 {
8279 ScAddress aAdr;
8282 else
8284 }
8285 }
8286 }
8287 }
8290 {
8291 ScRange aRange;
8295 else
8296 {
8297 ScAddress aAdr;
8300 else
8302 }
8303 }
8306 {
8307 ScAddress aAdr;
8311 else
8313 }
8318 }
8320 {
8323 }
8324 else
8325 {
8328 }
8329 }
8333 {
8338 static const sal_Unicode cre[] = { '.','*','+','?','[',']','^','$','\\','<','>','(',')','|', 0 };
8340 sal_Unicode c1;
8342 {
8345 {
8348 }
8349 }
8351 }
8355 {
8359 {
8360 // range lookup <= or >=
8361 SCCOL nCol;
8362 SCROW nRow;
8365 {
8368 }
8369 }
8371 {
8372 // EQUAL
8376 }
8378 }
8382 {
8389 else
8390 {
8398 {
8411 }
8412 }
8414 }
8416 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */