| blob | 48cf41f791bba66690e2a9ac248f4786464c1435 |
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: interpr1.cxx,v $
10 * $Revision: 1.61 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
31 // MARKER(update_precomp.py): autogen include statement, do not remove
34 // INCLUDE ---------------------------------------------------------------
37 #include <svx/langitem.hxx>
38 #include <svx/algitem.hxx>
39 #include <unotools/textsearch.hxx>
40 #include <svtools/zforlist.hxx>
41 #include <svtools/zformat.hxx>
42 #include <tools/urlobj.hxx>
43 #include <unotools/charclass.hxx>
44 #include <sfx2/docfile.hxx>
45 #include <sfx2/printer.hxx>
46 #include <unotools/collatorwrapper.hxx>
47 #include <unotools/transliterationwrapper.hxx>
48 #include <rtl/ustring.hxx>
49 #include <rtl/logfile.hxx>
63 #ifndef _COMPHELPER_PROCESSFACTORY_HXX_
64 #include <comphelper/processfactory.hxx>
65 #endif
67 #include <stdlib.h>
68 #include <string.h>
69 #include <math.h>
70 #include <vector>
71 #include <memory>
77 #include <basic/sbstar.hxx>
81 #define SC_DOUBLE_MAXVALUE 1.7e307
92 //-----------------------------------------------------------------------------
93 // Funktionen
94 //-----------------------------------------------------------------------------
98 {
104 {
106 {
110 else
111 {
112 FormulaTokenRef xNew;
114 // DoubleError handled by JumpMatrix
123 else
124 {
127 {
129 {
134 nType);
137 {
143 }
144 else
145 {
146 // Treat empty and empty path as 0, but string
147 // as error.
151 }
159 }
160 else
165 }
166 }
167 else
174 }
175 else
177 // or DoubleError
181 }
182 }
183 }
184 }
187 }
189 // set endpoint of path for main code line
191 }
192 }
195 {
201 }
202 else
207 }
208 }
209 else
214 }
215 else
220 }
221 }
222 }
223 }
224 }
228 {
230 // We have to set a jump, if there was none chosen because of an error set
231 // it to endpoint.
237 {
239 {
243 else
244 {
245 FormulaTokenRef xNew;
247 // DoubleError handled by JumpMatrix
256 else
257 {
260 {
262 {
264 ScMatValType nType;
266 nType);
269 {
273 {
276 {
279 errIllegalArgument);
280 }
281 }
282 }
283 else
284 {
286 }
288 {
292 }
293 else
294 {
298 }
299 }
300 }
304 }
306 // set endpoint of path for main code line
309 }
310 }
313 {
316 {
319 }
320 else
322 }
323 }
326 }
328 void lcl_AdjustJumpMatrix( ScJumpMatrix* pJumpM, ScMatrixRef& pResMat, SCSIZE nParmCols, SCSIZE nParmRows )
329 {
337 {
339 {
342 }
344 {
347 }
348 else
349 {
352 }
355 }
356 }
359 {
365 {
368 else
369 {
371 }
374 {
377 }
378 else
379 {
382 {
384 {
387 {
390 }
392 }
395 {
398 {
402 }
403 else
405 }
408 {
409 ScAddress aAdr;
412 {
416 }
417 else
418 {
423 {
426 {
428 nGlobalError);
430 }
432 }
433 else
434 {
435 String aStr;
438 {
442 }
443 else
445 }
446 }
447 }
452 ScRange aRange;
455 {
459 }
460 else
461 {
462 // Do not modify the original range because we use it
463 // to adjust the size of the result matrix if necessary.
471 {
474 }
475 else
476 {
477 // Replicate column and/or row of a vector if it is
478 // one. Note that this could be a range reference
479 // that in fact consists of only one cell, e.g. A1:A1
490 {
493 {
495 nGlobalError);
497 }
499 }
500 else
501 {
502 String aStr;
505 {
509 }
510 else
512 }
513 }
517 }
518 }
525 {
529 }
531 {
534 }
535 else
536 {
541 {
544 }
545 else
546 {
548 {
551 }
554 else
555 {
558 }
559 }
561 }
562 }
565 {
570 }
573 {
577 }
578 }
579 }
580 }
583 {
590 {
591 // a FALSE without path results in an empty path value
594 else
596 }
600 }
602 {
605 {
608 {
609 // This is not the current state of the interpreter, so
610 // push without error, and elements' errors are coded into
611 // double.
613 }
614 }
616 }
617 }
623 // Remove jump matrix from map and remember result matrix in case it
624 // could be reused in another path of the same condition.
626 {
630 }
632 }
634 }
642 {
644 // Interpreter functions usually are case insensitive, except the simple
645 // comparison operators, for which these options aren't used. Override in
646 // struct if needed.
647 }
651 {
653 // Keep DoubleError if encountered
654 // #i40539# if bEmpty is set, bVal/nVal are uninitialized
662 {
666 {
668 {
671 else
673 }
674 // else: empty cell == 0.0
675 }
676 else
677 {
680 // else: empty cell == ""
681 }
682 }
684 {
686 {
688 {
691 else
693 }
694 // else: empty cell == 0.0
695 }
696 else
697 {
700 // else: "" == empty cell
701 }
702 }
704 {
706 {
708 {
711 else
713 }
714 }
715 else
717 }
720 else
721 {
722 // Both strings.
724 {
725 // All similar to Sctable::ValidQuery(), *rComp.pVal[1] actually
726 // is/must be identical to *rEntry.pStr, which is essential for
727 // regex to work through GetSearchTextPtr().
731 {
740 }
742 {
749 else
750 {
758 }
760 }
764 else
767 }
771 else
774 }
776 }
780 {
785 {
787 {
802 {
803 ScAddress aAdr;
810 {
813 }
814 else
815 {
818 }
819 }
824 }
825 }
830 }
834 {
839 ScAddress aAdr;
841 {
843 {
857 {
863 {
866 }
867 else
868 {
871 }
872 }
879 else
881 // errors are transported as DoubleError inside matrix
886 }
887 }
890 {
892 {
903 {
905 {
909 {
911 {
913 {
917 }
918 else
919 {
923 }
924 }
926 }
927 else
929 }
930 }
931 }
933 {
942 {
944 {
948 }
949 else
950 {
954 }
956 }
957 }
958 }
961 }
965 {
971 else
977 {
980 }
983 {
1004 DBG_ERROR1( "ScInterpreter::QueryMat: unhandled comparison operator: %d", (int)rOptions.aQueryEntry.eOp);
1005 }
1007 }
1011 {
1014 {
1018 else
1019 {
1022 }
1023 }
1024 else
1026 }
1030 {
1033 {
1037 else
1038 {
1041 }
1042 }
1043 else
1045 }
1049 {
1052 {
1056 else
1057 {
1060 }
1061 }
1062 else
1064 }
1068 {
1071 {
1075 else
1076 {
1079 }
1080 }
1081 else
1083 }
1087 {
1090 {
1094 else
1095 {
1098 }
1099 }
1100 else
1102 }
1106 {
1109 {
1113 else
1114 {
1117 }
1118 }
1119 else
1121 }
1125 {
1130 {
1135 {
1137 {
1139 {
1149 {
1150 ScAddress aAdr;
1153 {
1156 {
1159 }
1160 // else: Xcl setzt hier keinen Fehler
1161 }
1162 }
1166 {
1167 ScRange aRange;
1170 {
1175 {
1177 do
1178 {
1182 }
1184 }
1185 }
1188 {
1191 {
1196 {
1199 }
1200 else
1202 }
1203 // else: GetMatrix did set errIllegalParameter
1204 }
1209 }
1210 }
1211 else
1213 }
1216 else
1218 }
1219 }
1223 {
1228 {
1233 {
1235 {
1237 {
1247 {
1248 ScAddress aAdr;
1251 {
1254 {
1257 }
1258 // else: Xcl setzt hier keinen Fehler
1259 }
1260 }
1264 {
1265 ScRange aRange;
1268 {
1273 {
1275 do
1276 {
1280 }
1282 }
1283 }
1286 {
1290 {
1295 {
1298 }
1299 else
1301 }
1302 // else: GetMatrix did set errIllegalParameter
1303 }
1308 }
1309 }
1310 else
1312 }
1315 else
1317 }
1318 }
1322 {
1324 // Simple negation doesn't change current format type to number, keep
1325 // current type.
1328 {
1330 {
1334 else
1335 {
1341 else
1342 {
1345 {
1348 else
1351 }
1353 }
1354 }
1355 }
1359 }
1360 }
1364 {
1376 }
1380 {
1384 {
1386 {
1390 else
1391 {
1397 else
1398 {
1401 {
1404 else
1407 }
1409 }
1410 }
1411 }
1415 }
1416 }
1420 {
1423 }
1427 {
1430 }
1434 {
1438 }
1442 {
1446 }
1450 {
1453 }
1457 {
1460 }
1464 {
1467 }
1471 {
1474 }
1478 {
1481 }
1485 {
1488 }
1492 {
1495 }
1499 {
1502 }
1506 {
1509 }
1513 {
1516 }
1520 {
1523 }
1527 {
1530 }
1534 {
1537 }
1541 {
1544 }
1548 {
1551 }
1554 {
1559 else
1561 }
1564 {
1569 else
1571 }
1575 {
1580 else
1582 }
1586 {
1589 }
1593 {
1598 else
1600 }
1604 {
1609 {
1611 {
1615 }
1619 {
1620 ScAddress aAdr;
1623 // NOTE: this could test also on inherited emptiness, but then the
1624 // cell tested wouldn't be empty. Must correspond with
1625 // ScCountEmptyCells().
1626 // if (HasCellEmptyData( GetCell( aAdr)))
1630 }
1633 {
1639 else
1640 {
1646 // else: FALSE, not empty (which is what Xcl does)
1647 }
1648 }
1652 }
1655 }
1659 {
1664 {
1671 {
1672 ScAddress aAdr;
1677 {
1679 {
1690 }
1691 }
1692 }
1695 {
1701 else
1702 {
1708 }
1709 }
1713 }
1716 }
1720 {
1723 }
1727 {
1730 }
1734 {
1738 {
1741 {
1742 ScAddress aAdr;
1747 {
1749 {
1753 }
1754 }
1755 }
1758 // TODO: we don't have type information for arrays except
1759 // numerical/string.
1760 // Fall thru
1765 }
1769 }
1773 {
1777 {
1780 {
1781 ScAddress aAdr;
1786 {
1788 {
1789 // NOTE: this is Xcl nonsense!
1798 {
1803 else
1805 }
1812 }
1813 }
1814 else
1816 }
1821 {
1824 }
1825 else
1831 {
1834 }
1835 else
1837 // we could return the type of one element if in JumpMatrix or
1838 // ForceArray mode, but Xcl doesn't ...
1843 {
1846 }
1847 else
1849 }
1851 }
1855 {
1857 }
1861 {
1863 }
1870 {
1878 else
1879 {
1880 String aFuncResult;
1885 // *** ADDRESS INFO ***
1889 }
1893 }
1897 }
1903 }
1908 {
1911 else
1912 {
1915 {
1920 String aTabName;
1923 }
1924 }
1925 }
1927 }
1930 // Yes, passing tab as col is intentional!
1934 String aCellStr;
1939 }
1941 // *** CELL PROPERTIES ***
1945 {
1948 }
1949 else
1951 }
1956 else
1959 }
1965 Font aDefFont;
1968 // font color doesn't matter here
1976 }
1980 {
1984 {
1991 }
1992 }
1994 }
2000 }
2002 // *** FORMATTING ***
2012 {
2018 {
2021 {
2029 case NF_DATE_DIN_DMMMMYYYY: aFuncResult.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "D1" ) ); break;
2041 }
2042 }
2043 }
2052 }
2057 }
2062 }
2063 else
2065 }
2066 }
2067 }
2071 {
2076 {
2078 {
2079 ScAddress aAdr;
2083 }
2086 {
2087 ScRange aRange;
2091 }
2094 {
2098 }
2102 }
2105 }
2109 {
2114 {
2121 {
2122 ScAddress aAdr;
2127 {
2129 {
2139 }
2140 }
2141 }
2144 {
2149 {
2152 }
2153 else
2154 {
2161 }
2162 }
2166 }
2169 }
2173 {
2178 {
2181 {
2182 ScAddress aAdr;
2186 }
2190 }
2193 }
2197 {
2199 String aFormula;
2201 {
2204 {
2205 ScAddress aAdr;
2210 {
2216 }
2217 }
2222 }
2224 }
2229 {
2234 {
2237 {
2238 ScAddress aAdr;
2242 else
2243 {
2247 }
2248 }
2251 {
2257 else
2258 {
2264 }
2265 }
2271 }
2274 }
2278 {
2283 {
2286 {
2287 ScAddress aAdr;
2291 else
2292 {
2296 }
2297 }
2300 {
2305 {
2308 }
2309 else
2310 {
2315 {
2318 }
2319 }
2320 }
2326 }
2329 }
2333 {
2338 {
2341 {
2342 ScAddress aAdr;
2344 {
2347 }
2350 else
2351 {
2354 }
2355 }
2358 {
2364 else
2365 {
2371 }
2372 }
2378 }
2381 }
2385 {
2391 {
2394 {
2395 ScAddress aAdr;
2402 else
2403 {
2405 {
2412 {
2415 }
2419 }
2420 }
2421 }
2424 {
2427 }
2430 {
2435 {
2439 }
2440 else
2441 {
2446 {
2450 }
2451 else
2453 }
2454 }
2458 }
2461 else
2464 }
2468 {
2471 }
2475 {
2478 }
2482 {
2488 {
2491 }
2492 else
2499 }
2507 String aStr;
2511 {
2514 p++;
2515 }
2517 }
2521 {
2526 }
2530 {
2532 //2do: what to do with I18N-CJK ?!?
2535 // #i82487# don't try to write to empty string's BufferAccess
2536 // (would crash now that the empty string is const)
2538 {
2548 {
2552 else
2554 nPos++;
2555 }
2557 }
2559 }
2563 {
2568 }
2572 {
2576 }
2580 {
2583 {
2586 {
2587 ScAddress aAdr;
2589 {
2592 }
2596 {
2598 {
2607 }
2608 }
2611 else
2612 {
2613 // wie GetString()
2616 }
2617 }
2620 {
2623 }
2630 }
2631 }
2635 {
2637 String aInputString;
2641 {
2649 //break;
2653 {
2654 ScAddress aAdr;
2656 {
2659 }
2664 {
2667 }
2668 else
2669 {
2672 }
2673 }
2676 {
2678 aInputString);
2680 {
2683 // fallthru
2688 //break;
2690 // evaluated below
2694 }
2695 }
2700 }
2705 else
2707 }
2710 //2do: this should be a proper unicode string method
2712 {
2714 }
2717 {
2721 {
2724 }
2726 }
2730 {
2732 //2do: make it full range unicode?
2734 PushInt( (sal_uChar) ByteString::ConvertFromUnicode( rStr.GetChar(0), gsl_getSystemTextEncoding() ) );
2735 }
2739 {
2741 //2do: make it full range unicode?
2745 else
2746 {
2748 aStr.SetChar( 0, ByteString::ConvertToUnicode( (sal_Char) fVal, gsl_getSystemTextEncoding() ) );
2750 }
2751 }
2754 /* #i70213# fullwidth/halfwidth conversion provided by
2755 * Takashi Nakamoto <bluedwarf@ooo>
2756 * erAck: added Excel compatibility conversions as seen in issue's test case. */
2759 {
2764 {
2765 aTrans.loadModuleByImplName( ::rtl::OUString::createFromAscii( "FULLWIDTH_HALFWIDTH_LIKE_ASC" ), LANGUAGE_SYSTEM );
2767 }
2770 }
2774 {
2779 {
2780 aTrans.loadModuleByImplName( ::rtl::OUString::createFromAscii( "HALFWIDTH_FULLWIDTH_LIKE_JIS" ), LANGUAGE_SYSTEM );
2782 }
2785 }
2788 /* ODFF:
2789 * Summary: Converts half-width to full-width ASCII and katakana characters.
2790 * Semantics: Conversion is done for half-width ASCII and katakana characters,
2791 * other characters are simply copied from T to the result. This is the
2792 * complementary function to ASC.
2793 * For references regarding halfwidth and fullwidth characters see
2794 * http://www.unicode.org/reports/tr11/
2795 * http://www.unicode.org/charts/charindex2.html#H
2796 * http://www.unicode.org/charts/charindex2.html#F
2797 */
2799 {
2803 }
2806 /* ODFF:
2807 * Summary: Converts full-width to half-width ASCII and katakana characters.
2808 * Semantics: Conversion is done for full-width ASCII and katakana characters,
2809 * other characters are simply copied from T to the result. This is the
2810 * complementary function to JIS.
2811 */
2813 {
2817 }
2820 {
2823 {
2827 else
2828 {
2831 }
2832 }
2833 }
2836 {
2839 {
2843 else
2844 {
2848 }
2849 }
2850 }
2854 {
2861 ScAddress aAdr;
2862 ScRange aRange;
2865 {
2867 {
2869 {
2873 }
2876 {
2880 {
2884 }
2886 {
2889 }
2890 }
2894 {
2899 {
2904 {
2907 }
2909 }
2910 }
2913 {
2916 {
2921 {
2924 {
2927 }
2928 }
2929 else
2930 {
2932 {
2934 {
2936 {
2939 }
2941 {
2944 }
2945 }
2946 }
2947 }
2948 }
2949 }
2952 {
2955 {
2958 }
2959 else
2961 }
2966 }
2967 }
2970 else
2972 }
2974 #if defined(WIN) && defined(MSC)
2976 #endif
2979 {
2986 ScAddress aAdr;
2987 ScRange aRange;
2990 {
2992 {
2994 {
2998 }
3001 {
3005 {
3009 }
3011 {
3014 }
3015 }
3019 {
3024 {
3029 {
3032 }
3034 }
3035 }
3038 {
3041 {
3046 {
3049 {
3052 }
3053 }
3054 else
3055 {
3057 {
3059 {
3061 {
3064 }
3066 {
3069 }
3070 }
3071 }
3072 }
3073 }
3074 }
3077 {
3080 {
3083 }
3084 else
3086 }
3091 }
3092 }
3095 else
3097 }
3098 #if defined(WIN) && defined(MSC)
3100 #endif
3104 {
3112 ScAddress aAdr;
3113 ScRange aRange;
3118 {
3120 {
3123 {
3125 {
3129 nCount++;
3130 }
3131 else
3132 {
3134 {
3139 {
3141 {
3143 nCount++;
3146 }
3147 else
3148 {
3152 }
3153 }
3157 nCount++;
3158 }
3159 }
3160 }
3164 nCount++;
3166 {
3170 {
3173 }
3174 else
3180 }
3184 {
3187 {
3192 }
3195 {
3197 {
3200 nCount++;
3203 }
3205 {
3206 nCount++;
3210 {
3214 {
3217 }
3218 else
3225 {
3227 nCount--;
3228 }
3231 }
3232 }
3234 {
3235 nCount++;
3238 }
3239 }
3240 }
3244 {
3248 {
3253 }
3255 {
3259 {
3260 do
3261 {
3264 nCount++;
3265 }
3267 }
3270 }
3271 else
3272 {
3275 {
3276 // Schleife aus Performance-Gruenden nach innen verlegt:
3279 {
3282 do
3283 {
3286 {
3289 }
3290 else
3292 nCount++;
3293 }
3297 do
3298 {
3301 nCount++;
3302 }
3306 do
3307 {
3310 nCount++;
3311 }
3315 do
3316 {
3318 nCount++;
3319 }
3323 }
3325 }
3326 }
3327 }
3330 {
3333 {
3339 else
3340 {
3342 {
3344 {
3346 {
3347 nCount++;
3350 {
3354 {
3357 }
3358 else
3364 }
3365 }
3367 {
3368 nCount++;
3371 }
3372 }
3373 }
3374 }
3375 }
3376 }
3379 {
3382 {
3384 }
3386 {
3387 nCount++;
3389 }
3390 }
3396 }
3397 }
3399 {
3406 }
3407 // Bei Summen etc. macht ein BOOL-Ergebnis keinen Sinn
3408 // und Anzahl ist immer Number (#38345#)
3412 }
3416 {
3419 }
3423 {
3426 }
3430 {
3433 }
3437 {
3440 }
3444 {
3447 }
3451 {
3454 }
3458 BOOL bTextAsZero )
3459 {
3469 ScAddress aAdr;
3470 ScRange aRange;
3473 {
3475 {
3477 {
3481 rValCount++;
3482 }
3485 {
3489 {
3493 rValCount++;
3494 }
3496 {
3498 rValCount++;
3499 }
3500 }
3504 {
3509 {
3510 do
3511 {
3514 rValCount++;
3515 }
3517 }
3518 }
3521 {
3524 {
3528 {
3530 {
3532 {
3536 rValCount++;
3537 }
3539 {
3541 rValCount++;
3542 }
3543 }
3544 }
3545 }
3546 }
3549 {
3552 {
3554 rValCount++;
3555 }
3556 else
3558 }
3563 }
3564 }
3571 }
3575 {
3583 else
3585 }
3589 {
3596 }
3600 {
3607 else
3609 }
3613 {
3620 else
3623 /* this was: PushDouble( sqrt( div( nVal, nValCount)));
3624 *
3625 * Besides that the special NAN gets lost in the call through sqrt(),
3626 * unxlngi6.pro then looped back and forth somewhere between div() and
3627 * ::rtl::math::setNan(). Tests showed that
3628 *
3629 * sqrt( div( 1, 0));
3630 *
3631 * produced a loop, but
3632 *
3633 * double f1 = div( 1, 0);
3634 * sqrt( f1 );
3635 *
3636 * was fine. There seems to be some compiler optimization problem. It does
3637 * not occur when compiled with debug=t.
3638 */
3639 }
3643 {
3647 SCCOL nCol1;
3648 SCROW nRow1;
3649 SCTAB nTab1;
3650 SCCOL nCol2;
3651 SCROW nRow2;
3652 SCTAB nTab2;
3654 {
3656 {
3659 nVal++;
3667 {
3670 {
3674 }
3675 }
3680 }
3681 }
3683 }
3687 {
3691 SCCOL nCol1;
3692 SCROW nRow1;
3693 SCTAB nTab1;
3694 SCCOL nCol2;
3695 SCROW nRow2;
3696 SCTAB nTab2;
3698 {
3700 {
3703 nVal++;
3711 {
3714 {
3718 }
3719 }
3724 }
3725 }
3727 }
3730 {
3733 ULONG nVal;
3736 else
3737 {
3739 SCCOL nCol1;
3740 SCROW nRow1;
3741 SCTAB nTab1;
3742 SCCOL nCol2;
3743 SCROW nRow2;
3744 SCTAB nTab2;
3746 {
3748 {
3751 nVal++;
3759 nVal++;
3764 }
3765 }
3766 }
3768 }
3772 {
3776 {
3779 {
3782 {
3783 SCCOL nCols;
3784 SCROW nRows;
3788 {
3793 }
3794 }
3795 }
3796 else
3797 {
3799 {
3801 {
3802 SCCOL nCol1;
3803 SCROW nRow1;
3804 SCTAB nTab1;
3807 }
3810 {
3811 SCCOL nCol1;
3812 SCROW nRow1;
3813 SCTAB nTab1;
3814 SCCOL nCol2;
3815 SCROW nRow2;
3816 SCTAB nTab2;
3819 {
3823 {
3829 }
3830 else
3832 }
3833 else
3835 }
3840 }
3841 }
3843 }
3844 }
3848 {
3852 {
3855 {
3858 {
3859 SCCOL nCols;
3860 SCROW nRows;
3864 {
3869 }
3870 }
3871 }
3872 else
3873 {
3875 {
3877 {
3878 SCCOL nCol1;
3879 SCROW nRow1;
3880 SCTAB nTab1;
3883 }
3886 {
3887 SCCOL nCol1;
3888 SCROW nRow1;
3889 SCTAB nTab1;
3890 SCCOL nCol2;
3891 SCROW nRow2;
3892 SCTAB nTab2;
3895 {
3899 {
3905 }
3906 else
3908 }
3909 else
3911 }
3916 }
3917 }
3919 }
3920 }
3923 {
3927 {
3931 else
3932 {
3934 {
3936 {
3940 else
3942 }
3945 {
3946 SCCOL nCol1;
3947 SCROW nRow1;
3948 SCTAB nTab1;
3951 }
3954 {
3955 SCCOL nCol1;
3956 SCROW nRow1;
3957 SCTAB nTab1;
3958 SCCOL nCol2;
3959 SCROW nRow2;
3960 SCTAB nTab2;
3963 }
3967 }
3970 }
3972 }
3973 }
3975 /** returns -1 when the matrix value is smaller than the query value, 0 when
3976 they are equal, and 1 when the matrix value is larger than the query
3977 value. */
3980 {
3982 {
3983 /* TODO: in case we introduced query for real empty this would have to
3984 * be changed! */
3986 }
3988 /* FIXME: what is an empty path (result of IF(false;true_path) in
3989 * comparisons? */
3992 {
4002 }
4008 // this should not happen!
4015 }
4017 /** returns the last item with the identical value as the original item
4018 value. */
4021 {
4023 {
4029 else
4033 }
4034 //! Order of IsEmptyPath, IsEmpty, IsString is significant!
4036 {
4040 else
4043 }
4045 {
4049 else
4052 }
4054 {
4060 else
4064 }
4065 else
4066 {
4068 }
4069 }
4072 {
4078 {
4082 else
4091 {
4094 {
4097 }
4098 }
4100 {
4103 {
4106 }
4107 }
4108 else
4109 {
4112 }
4114 {
4116 String sStr;
4117 ScQueryParam rParam;
4131 {
4133 {
4137 }
4140 {
4144 }
4148 {
4149 ScAddress aAdr;
4151 {
4154 }
4157 {
4161 }
4162 else
4163 {
4167 }
4168 }
4171 {
4175 }
4178 {
4181 }
4182 }
4184 {
4187 {
4191 }
4192 // #TODO handle MSO wildcards
4195 else
4197 }
4200 {
4204 {
4205 // The source matrix must be a vector.
4208 }
4211 // simple serial search for equality mode (source data doesn't
4212 // need to be sorted).
4215 {
4217 {
4219 {
4222 }
4223 }
4226 }
4228 // binary search for non-equality mode (the source data is
4229 // assumed to be sorted).
4234 {
4238 {
4239 // exact match. find the last item with the same value.
4243 }
4246 {
4249 else
4252 }
4255 {
4258 else
4260 }
4261 else
4262 {
4265 else
4267 }
4268 }
4271 {
4274 {
4275 // either the last item is an exact match or the real
4276 // hit is beyond the last item.
4279 }
4280 }
4283 {
4286 }
4290 }
4299 {
4302 }
4304 }
4305 else
4307 SCCOL nC;
4312 // Advance Entry.nField in Iterator if column changed
4318 else
4319 {
4322 }
4323 }
4324 else
4326 SCROW nR;
4328 {
4331 }
4332 }
4334 }
4336 }
4337 else
4339 }
4340 }
4344 {
4347 {
4349 CellType eCellType;
4351 {
4353 {
4355 ScAddress aAdr;
4360 }
4364 {
4365 ScRange aRange;
4369 {
4371 nMaxCount +=
4378 {
4379 do
4380 {
4383 nCount++;
4385 }
4386 }
4387 }
4390 }
4392 }
4393 }
4397 {
4400 {
4401 String rString;
4405 {
4408 {
4409 ScAddress aAdr;
4411 {
4414 }
4417 {
4424 {
4427 }
4428 else
4438 }
4439 }
4442 {
4444 rString);
4446 }
4452 {
4455 }
4456 }
4461 {
4462 SCCOL nCol1;
4463 SCROW nRow1;
4464 SCTAB nTab1;
4465 SCCOL nCol2;
4466 SCROW nRow2;
4467 SCTAB nTab2;
4468 ScMatrixRef pQueryMatrix;
4470 {
4473 {
4474 ScRange aRange;
4477 }
4486 {
4489 {
4492 }
4501 }
4506 }
4508 {
4511 }
4513 {
4516 }
4518 {
4519 ScQueryParam rParam;
4526 {
4530 }
4531 else
4532 {
4540 }
4545 {
4546 // Never case-sensitive.
4550 {
4553 }
4557 {
4561 }
4562 }
4563 else
4564 {
4566 // Entry.nField im Iterator bei Spaltenwechsel weiterschalten
4569 {
4570 do
4571 {
4572 fSum++;
4574 }
4575 }
4576 }
4577 else
4578 {
4581 }
4582 }
4584 }
4585 }
4589 {
4593 {
4598 ScMatrixRef pSumExtraMatrix;
4601 {
4602 // Save only the upperleft cell in case of cell range. The geometry
4603 // of the 3rd parameter is taken from the 1st parameter.
4606 {
4608 {
4614 {
4617 }
4618 }
4625 //! nCol3, nRow3, nTab3 remain 0
4630 }
4631 }
4632 String rString;
4636 {
4639 {
4640 ScAddress aAdr;
4642 {
4645 }
4648 {
4655 {
4658 }
4659 else
4669 }
4670 }
4676 {
4678 rString);
4680 }
4683 {
4686 }
4687 }
4695 {
4696 SCCOL nCol1;
4697 SCROW nRow1;
4698 SCTAB nTab1;
4699 SCCOL nCol2;
4700 SCROW nRow2;
4701 SCTAB nTab2;
4702 ScMatrixRef pQueryMatrix;
4704 {
4707 {
4710 }
4711 else
4712 {
4713 ScRange aRange;
4716 }
4728 {
4731 {
4734 }
4743 }
4748 }
4750 {
4753 }
4756 {
4757 // Take the range geometry of the 1st parameter and apply it to
4758 // the 3rd. If parts of the resulting range would point outside
4759 // the sheet, don't complain but silently ignore and simply cut
4760 // them away, this is what Xcl does :-/
4762 // For the cut-away part we also don't need to determine the
4763 // criteria match, so shrink the source range accordingly,
4764 // instead of the result range.
4767 SCCOL nMaxCol;
4768 SCROW nMaxRow;
4770 {
4775 }
4776 else
4777 {
4780 }
4782 {
4785 }
4788 {
4791 }
4792 }
4793 else
4794 {
4798 }
4801 {
4802 ScQueryParam rParam;
4809 {
4813 }
4814 else
4815 {
4823 }
4824 ScAddress aAdr;
4832 {
4833 // Never case-sensitive.
4837 {
4840 }
4843 {
4845 {
4847 {
4850 {
4854 {
4857 {
4860 }
4861 else
4863 }
4864 }
4865 }
4866 }
4867 }
4868 else
4869 {
4871 {
4873 {
4875 {
4880 {
4883 {
4886 }
4887 else
4889 }
4890 }
4891 }
4892 }
4893 }
4894 }
4895 else
4896 {
4898 // Increment Entry.nField in iterator when switching to next column.
4901 {
4903 {
4904 do
4905 {
4909 {
4912 {
4915 }
4916 else
4918 }
4920 }
4921 else
4922 {
4923 do
4924 {
4929 {
4932 {
4935 }
4936 else
4938 }
4940 }
4941 }
4942 }
4943 }
4944 else
4945 {
4948 }
4949 }
4951 }
4952 }
4956 {
4969 // The third parameter, result array, for double, string and single reference.
4971 String aResStr;
4972 ScAddress aResAdr;
4976 {
4979 {
4981 {
4982 SCTAB nTabJunk;
4987 {
4988 // The result array must be a vector.
4991 }
4992 }
4995 {
4998 {
5001 }
5005 {
5006 // Result matrix must be a vector.
5009 }
5010 }
5024 }
5025 }
5027 // For double, string and single reference.
5029 String aDataStr;
5030 ScAddress aDataAdr;
5033 // Get the data-result range and also determine whether this is vertical
5034 // lookup or horizontal lookup.
5038 {
5040 {
5041 SCTAB nTabJunk;
5044 {
5047 }
5050 }
5053 {
5056 {
5059 }
5065 }
5068 {
5071 }
5074 {
5076 }
5079 {
5083 {
5084 // Empty cells aren't found anywhere, bail out early.
5086 }
5088 {
5091 }
5092 else
5094 }
5098 }
5102 {
5105 }
5107 // Get the lookup value.
5109 ScQueryParam aParam;
5116 {
5117 // Delta position for a single value is always 0.
5119 // Found if data <= query, but not if query is string and found data is
5120 // numeric or vice versa. This is how Excel does it but doesn't
5121 // document it.
5125 {
5128 else
5130 }
5131 else
5132 {
5135 else
5137 }
5140 {
5143 }
5146 {
5149 else
5151 }
5153 {
5155 {
5164 // fallthru
5170 }
5171 }
5172 else
5173 {
5175 {
5187 }
5188 }
5190 }
5192 // Now, perform the search to compute the delta position (nDelta).
5195 {
5196 // Data array is given as a matrix.
5204 // In case of non-vector matrix, only search the first row or column.
5205 ScMatrixRef pDataMat2;
5207 {
5212 else
5215 }
5216 else
5217 {
5222 else
5225 }
5227 // binary search for non-equality mode (the source data is
5228 // assumed to be sorted in ascending order).
5234 {
5238 {
5239 // exact match. find the last item with the same value.
5244 }
5247 {
5249 // If already the 1st item is greater there's nothing found.
5252 }
5256 else
5258 }
5261 {
5264 {
5265 // either the last item is an exact match or the real
5266 // hit is beyond the last item.
5269 }
5270 }
5272 {
5273 // non-exact match
5275 }
5277 // With 0-9 < A-Z, if query is numeric and data found is string, or
5278 // vice versa, the (yet another undocumented) Excel behavior is to
5279 // return #N/A instead.
5282 {
5289 }
5292 {
5295 }
5297 // Now that we've found the delta, push the result back to the cell.
5300 {
5301 // result array is matrix.
5303 {
5306 }
5309 else
5311 }
5313 {
5314 // result array is cell range.
5315 ScAddress aAdr;
5319 {
5322 {
5325 }
5328 }
5329 else
5330 {
5333 {
5336 }
5339 }
5341 }
5342 else
5343 {
5344 // no result array. Use the data array to get the final value from.
5346 {
5349 else
5351 }
5352 else
5353 {
5356 else
5358 }
5359 }
5362 }
5364 // Perform cell range search.
5380 SCCOL nC;
5381 SCROW nR;
5382 // Advance Entry.nField in iterator upon switching columns if
5383 // lookup in row.
5386 {
5389 }
5394 {
5395 // Use the matrix result array.
5398 else
5400 }
5402 {
5404 {
5406 {
5407 // Use the result array vector. Note that the result array is assumed
5408 // to be a vector (i.e. 1-dimensinoal array).
5410 ScAddress aAdr;
5414 {
5417 {
5420 }
5423 }
5424 else
5425 {
5428 {
5431 }
5434 }
5436 }
5441 {
5444 else
5445 {
5447 {
5459 }
5460 }
5461 }
5465 }
5466 }
5467 else
5468 {
5469 // Regardless of whether or not the result array exists, the last
5470 // array is always used as the "result" array.
5472 ScAddress aAdr;
5475 {
5478 {
5481 }
5484 }
5485 else
5486 {
5489 {
5492 }
5495 }
5497 }
5498 }
5502 {
5505 }
5507 {
5511 {
5512 BOOL bSorted;
5515 else
5525 SCTAB nTab2;
5527 {
5530 {
5533 }
5534 }
5536 {
5540 else
5541 {
5544 }
5545 }
5546 else
5547 {
5550 }
5551 if ( fIndex < 0.0 || (HLookup ? (pMat ? (fIndex >= nR) : (fIndex+nRow1 > nRow2)) : (pMat ? (fIndex >= nC) : (fIndex+nCol1 > nCol2)) ) )
5552 {
5555 }
5560 {
5563 }
5566 {
5567 ScQueryParam rParam;
5571 {
5576 else
5577 {
5581 }
5593 {
5597 {
5598 //!!!!!!!
5599 //! TODO: enable regex on matrix strings
5600 //!!!!!!!
5603 {
5606 {
5608 {
5609 sal_Int32 nRes =
5615 }
5616 else
5618 }
5619 }
5620 else
5621 {
5623 {
5625 {
5628 {
5631 }
5632 }
5633 }
5634 }
5635 }
5636 else
5637 {
5639 {
5640 // #i2168# ignore strings
5642 {
5644 {
5647 else
5649 }
5650 }
5651 }
5652 else
5653 {
5655 {
5657 {
5659 {
5662 }
5663 }
5664 }
5665 }
5666 }
5668 {
5672 {
5675 }
5678 else
5680 }
5681 else
5683 }
5684 else
5685 {
5693 {
5695 // advance Entry.nField in Iterator upon switching columns
5698 {
5699 SCROW nRow1_temp;
5701 }
5703 {
5706 }
5709 else
5710 {
5715 }
5717 {
5720 }
5721 else
5723 }
5724 }
5725 else
5727 }
5728 }
5731 {
5734 {
5736 {
5739 }
5742 {
5746 }
5750 {
5751 ScAddress aAdr;
5753 {
5756 }
5759 {
5762 }
5763 else
5764 {
5766 {
5769 }
5770 else
5771 {
5772 String sStr;
5776 }
5777 }
5778 }
5781 {
5784 }
5787 {
5790 }
5793 }
5795 {
5798 }
5800 #if defined(WIN) && defined(MSC)
5802 #endif
5805 {
5809 {
5810 // We must fish the 1st parameter deep from the stack! And push it on top.
5816 else
5817 {
5821 {
5834 }
5836 }
5837 // Get rid of the 1st (fished) parameter.
5841 }
5842 }
5843 #if defined(WIN) && defined(MSC)
5845 #endif
5849 {
5853 {
5856 }
5858 {
5859 // First, get the query criteria range.
5866 String aStr;
5867 ScRange aMissingRange;
5870 {
5881 {
5882 ScAddress aAdr;
5887 else
5888 {
5891 }
5892 }
5899 }
5900 else
5901 {
5904 }
5910 else
5916 }
5924 {
5925 // range parameter must match entire database range
5928 else
5930 }
5940 else
5941 {
5945 }
5953 {
5954 // An allowed missing field parameter sets the result field
5955 // to any of the query fields, just to be able to return
5956 // some cell from the iterator.
5963 {
5966 {
5972 }
5973 else
5975 }
5977 }
5978 }
5980 }
5984 {
5993 {
5997 {
5999 {
6004 }
6005 do
6006 {
6007 nCount++;
6009 {
6013 {
6016 }
6017 else
6025 }
6026 }
6028 }
6030 }
6031 else
6034 {
6039 }
6041 }
6045 {
6048 }
6052 {
6057 {
6061 // TODO: currently the QueryIterators only return cell pointers of
6062 // existing cells, so if a query matches an empty cell there's
6063 // nothing returned, and therefor not counted!
6064 // Since this has ever been the case and this code here only came
6065 // into existance to fix #i6899 and it never worked before we'll
6066 // have to live with it until we reimplement the iterators to also
6067 // return empty cells, which would mean to adapt all callers of
6068 // iterators.
6073 {
6074 do
6075 {
6076 nCount++;
6078 }
6079 }
6080 else
6085 {
6086 do
6087 {
6088 nCount++;
6089 }
6091 }
6093 }
6095 }
6096 else
6098 }
6102 {
6107 {
6113 {
6114 do
6115 {
6116 nCount++;
6117 }
6119 }
6122 }
6123 else
6125 }
6129 {
6132 }
6136 {
6139 }
6143 {
6146 }
6150 {
6153 }
6157 {
6168 {
6172 {
6173 do
6174 {
6175 rValCount++;
6178 }
6180 }
6182 }
6183 else
6192 }
6196 {
6201 }
6205 {
6210 }
6214 {
6219 }
6223 {
6228 }
6234 {
6240 {
6241 ScComplexRefData aRef;
6254 }
6255 else
6256 {
6257 ScSingleRefData aRef;
6265 }
6266 // The indirect usage of the external table can't be detected during the
6267 // store-to-file cycle, mark it as permanently referenced so it gets stored
6268 // even if not directly referenced anywhere.
6274 }
6278 {
6282 {
6286 {
6289 }
6299 {
6301 {
6302 /* TODO: future versions should implement a proper subroutine
6303 * token. This procedure here is a minimally invasive fix for
6304 * #i101645# in OOo3.1.1 */
6305 // Push a subroutine on the instruction code stack that
6306 // resolves the external reference as the next instruction.
6309 // Signal subroutine call to interpreter.
6311 }
6312 else
6315 }
6319 {
6321 {
6322 /* TODO: future versions should implement a proper subroutine
6323 * token. This procedure here is a minimally invasive fix for
6324 * #i101645# in OOo3.1.1 */
6325 // Push a subroutine on the instruction code stack that
6326 // resolves the external reference as the next instruction.
6329 // Signal subroutine call to interpreter.
6331 }
6332 else
6334 }
6335 else
6336 {
6337 do
6338 {
6351 // We need this in order to obtain a good range.
6354 ScRange aRange;
6355 #if 0
6356 // This is some really odd Excel behavior and renders named
6357 // ranges containing relative references totally useless.
6360 #else
6361 // This is the usual way to treat named ranges containing
6362 // relative references.
6365 #endif
6370 else
6375 // success!
6377 }
6381 }
6382 }
6383 }
6387 {
6389 String sTabStr;
6404 {
6407 {
6420 }
6421 }
6427 {
6428 // YUCK! The XL interface actually treats rel R1C1 refs differently
6429 // than A1
6434 }
6439 {
6442 }
6444 String aRefStr;
6450 {
6455 }
6456 else
6458 }
6462 {
6466 {
6474 SCCOL nCol1;
6475 SCROW nRow1;
6476 SCTAB nTab1;
6477 SCCOL nCol2;
6478 SCROW nRow2;
6479 SCTAB nTab2;
6481 {
6484 }
6486 {
6489 {
6494 else
6496 }
6497 else
6498 {
6510 else
6512 }
6513 }
6515 {
6528 else
6530 }
6531 else
6533 }
6534 }
6538 {
6542 {
6545 SCCOL nCol;
6546 SCROW nRow;
6549 else
6553 else
6557 else
6561 else
6564 {
6567 }
6569 {
6572 }
6574 {
6576 {
6582 {
6585 // Access one element of a vector independent of col/row
6586 // orientation?
6598 {
6602 else
6604 }
6606 {
6609 {
6615 else
6619 }
6620 else
6622 }
6624 {
6627 {
6633 else
6637 }
6638 else
6640 }
6641 else
6642 {
6648 else
6652 }
6653 }
6654 }
6657 {
6664 else
6666 }
6670 {
6679 {
6682 {
6685 }
6691 }
6692 else
6693 {
6697 }
6704 {
6707 else
6709 }
6711 {
6714 else
6717 }
6719 {
6723 {
6727 }
6728 else
6731 }
6732 else
6734 }
6738 }
6739 }
6740 }
6744 {
6746 // Legacy support, convert to RefList
6749 {
6751 {
6753 }
6754 }
6755 }
6759 {
6763 {
6766 {
6768 {
6772 }
6775 {
6779 }
6782 {
6786 }
6790 }
6792 }
6793 }
6797 {
6801 {
6802 String aStr;
6805 {
6808 {
6811 }
6812 }
6813 else
6819 else
6823 else
6829 NUMBERFORMAT_CURRENCY,
6832 {
6833 String sFormatString;
6835 nIndex,
6842 fVal,
6843 aStr,
6847 }
6848 else
6849 {
6851 }
6853 }
6854 }
6858 {
6861 {
6869 else
6870 {
6882 }
6883 }
6884 }
6888 {
6892 {
6893 String aStr;
6895 BOOL bThousand;
6898 else
6901 {
6904 {
6907 }
6908 }
6909 else
6915 else
6919 else
6922 String sFormatString;
6926 NUMBERFORMAT_NUMBER,
6929 nIndex,
6936 fVal,
6937 aStr,
6941 else
6943 }
6944 }
6948 {
6952 {
6956 else
6961 else
6962 {
6966 else
6968 }
6969 }
6970 }
6974 {
6978 {
6982 }
6983 }
6987 {
6991 {
6992 xub_StrLen n;
6994 {
6997 {
7000 }
7001 else
7003 }
7004 else
7009 }
7010 }
7014 {
7018 {
7019 xub_StrLen n;
7021 {
7024 {
7027 }
7028 else
7030 }
7031 else
7037 }
7038 }
7042 {
7047 {
7049 {
7052 {
7055 }
7056 }
7057 else
7065 else
7066 {
7075 else
7077 }
7078 }
7079 }
7083 {
7086 {
7090 if (fAnfang < 1.0 || fAnz < 0.0 || fAnfang > double(STRING_MAXLEN) || fAnz > double(STRING_MAXLEN))
7092 else
7094 }
7095 }
7099 {
7102 {
7105 String aStr;
7107 LanguageType eCellLang;
7113 else
7118 else
7120 }
7121 }
7125 {
7129 {
7130 xub_StrLen nAnz;
7132 {
7135 {
7138 }
7139 else
7141 }
7142 else
7152 {
7155 {
7156 nCount++;
7158 {
7161 {
7164 }
7165 else
7167 }
7168 else
7169 nPos++;
7170 }
7171 else
7173 }
7175 }
7176 }
7180 {
7183 {
7189 {
7191 }
7194 else
7195 {
7198 String aRes;
7202 {
7205 }
7207 }
7208 }
7209 }
7213 {
7216 String aRes;
7218 {
7221 }
7223 }
7227 {
7229 USHORT nErr;
7233 {
7235 {
7239 else
7240 {
7247 else
7248 {
7249 ScRange aRange;
7253 else
7254 {
7255 ScAddress aAdr;
7258 else
7260 }
7261 }
7262 }
7263 }
7266 {
7267 ScRange aRange;
7271 else
7272 {
7273 ScAddress aAdr;
7276 else
7278 }
7279 }
7282 {
7283 ScAddress aAdr;
7287 else
7289 }
7294 }
7296 {
7299 }
7300 else
7301 {
7304 }
7305 }
7309 {
7315 static const sal_Unicode cre[] = { '.','*','+','?','[',']','^','$','\\','<','>','(',')','|', 0 };
7317 sal_Unicode c1;
7319 {
7322 {
7325 }
7326 }
7328 }
7332 {
7336 {
7337 // range lookup <= or >=
7338 SCCOL nCol;
7339 SCROW nRow;
7342 {
7345 }
7346 }
7348 {
7349 // EQUAL
7353 }
7355 }
7357 #define erDEBUG_LOOKUPCACHE 0
7358 #if erDEBUG_LOOKUPCACHE
7359 #include <cstdio>
7362 static struct LookupCacheDebugCounter
7363 {
7368 {
7373 }
7375 #endif
7379 {
7387 else
7388 {
7396 {
7399 #if erDEBUG_LOOKUPCACHE
7401 #if erDEBUG_LOOKUPCACHE > 1
7403 #endif
7404 #endif
7410 #if erDEBUG_LOOKUPCACHE
7412 #if erDEBUG_LOOKUPCACHE > 1
7414 #endif
7415 #endif
7421 }
7422 }
7424 }