?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Resolves: tdf#162093 TableRef item specifier may occur standalone
[LibreOffice.git] / sc / source / core / tool / interpr1.cxx
blob73b25d541fa48722c8f002d9a6500b5157657f03
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 */
19
20 #include <interpre.hxx>
21
22 #include <scitems.hxx>
23 #include <editeng/langitem.hxx>
24 #include <editeng/justifyitem.hxx>
25 #include <o3tl/safeint.hxx>
26 #include <o3tl/temporary.hxx>
27 #include <osl/thread.h>
28 #include <unotools/textsearch.hxx>
29 #include <svl/numformat.hxx>
30 #include <svl/zforlist.hxx>
31 #include <svl/zformat.hxx>
32 #include <tools/urlobj.hxx>
33 #include <unotools/charclass.hxx>
34 #include <sfx2/docfile.hxx>
35 #include <sfx2/printer.hxx>
36 #include <unotools/collatorwrapper.hxx>
37 #include <unotools/transliterationwrapper.hxx>
38 #include <rtl/character.hxx>
39 #include <rtl/ustring.hxx>
40 #include <sal/log.hxx>
41 #include <osl/diagnose.h>
42 #include <unicode/uchar.h>
43 #include <unicode/regex.h>
44 #include <i18nlangtag/mslangid.hxx>
45
46 #include <patattr.hxx>
47 #include <global.hxx>
48 #include <document.hxx>
49 #include <dociter.hxx>
50 #include <docsh.hxx>
51 #include <sfx2/linkmgr.hxx>
52 #include <formulacell.hxx>
53 #include <scmatrix.hxx>
54 #include <docoptio.hxx>
55 #include <attrib.hxx>
56 #include <jumpmatrix.hxx>
57 #include <cellkeytranslator.hxx>
58 #include <lookupcache.hxx>
59 #include <rangenam.hxx>
60 #include <rangeutl.hxx>
61 #include <compiler.hxx>
62 #include <externalrefmgr.hxx>
63 #include <doubleref.hxx>
64 #include <queryparam.hxx>
65 #include <queryiter.hxx>
66 #include <tokenarray.hxx>
67 #include <compare.hxx>
68 #include <comphelper/lok.hxx>
69 #include <comphelper/processfactory.hxx>
70 #include <comphelper/string.hxx>
71 #include <svl/sharedstringpool.hxx>
72
73 #include <stdlib.h>
74 #include <memory>
75 #include <vector>
76 #include <limits>
77 #include <string_view>
78 #include <cmath>
79
80 const sal_uInt64 n2power48 = SAL_CONST_UINT64( 281474976710656); // 2^48
81
82 ScCalcConfig *ScInterpreter::mpGlobalConfig = nullptr;
83
84 using namespace formula;
85 using ::std::unique_ptr;
86
87 void ScInterpreter::ScIfJump()
88 {
89 const short* pJump = pCur->GetJump();
90 short nJumpCount = pJump[ 0 ];
91 MatrixJumpConditionToMatrix();
92 switch ( GetStackType() )
93 {
94 case svMatrix:
95 {
96 ScMatrixRef pMat = PopMatrix();
97 if ( !pMat )
98 PushIllegalParameter();
99 else
100 {
101 FormulaConstTokenRef xNew;
102 ScTokenMatrixMap::const_iterator aMapIter;
103 // DoubleError handled by JumpMatrix
104 pMat->SetErrorInterpreter( nullptr);
105 SCSIZE nCols, nRows;
106 pMat->GetDimensions( nCols, nRows );
107 if ( nCols == 0 || nRows == 0 )
108 {
109 PushIllegalArgument();
110 return;
111 }
112 else if ((aMapIter = maTokenMatrixMap.find( pCur)) != maTokenMatrixMap.end())
113 xNew = (*aMapIter).second;
114 else
115 {
116 std::shared_ptr<ScJumpMatrix> pJumpMat( std::make_shared<ScJumpMatrix>(
117 pCur->GetOpCode(), nCols, nRows));
118 for ( SCSIZE nC=0; nC < nCols; ++nC )
119 {
120 for ( SCSIZE nR=0; nR < nRows; ++nR )
121 {
122 double fVal;
123 bool bTrue;
124 bool bIsValue = pMat->IsValue(nC, nR);
125 if (bIsValue)
126 {
127 fVal = pMat->GetDouble(nC, nR);
128 bIsValue = std::isfinite(fVal);
129 bTrue = bIsValue && (fVal != 0.0);
130 if (bTrue)
131 fVal = 1.0;
132 }
133 else
134 {
135 // Treat empty and empty path as 0, but string
136 // as error. ScMatrix::IsValueOrEmpty() returns
137 // true for any empty, empty path, empty cell,
138 // empty result.
139 bIsValue = pMat->IsValueOrEmpty(nC, nR);
140 bTrue = false;
141 fVal = (bIsValue ? 0.0 : CreateDoubleError( FormulaError::NoValue));
142 }
143 if ( bTrue )
144 { // TRUE
145 if( nJumpCount >= 2 )
146 { // THEN path
147 pJumpMat->SetJump( nC, nR, fVal,
148 pJump[ 1 ],
149 pJump[ nJumpCount ]);
150 }
151 else
152 { // no parameter given for THEN
153 pJumpMat->SetJump( nC, nR, fVal,
154 pJump[ nJumpCount ],
155 pJump[ nJumpCount ]);
156 }
157 }
158 else
159 { // FALSE
160 if( nJumpCount == 3 && bIsValue )
161 { // ELSE path
162 pJumpMat->SetJump( nC, nR, fVal,
163 pJump[ 2 ],
164 pJump[ nJumpCount ]);
165 }
166 else
167 { // no parameter given for ELSE,
168 // or DoubleError
169 pJumpMat->SetJump( nC, nR, fVal,
170 pJump[ nJumpCount ],
171 pJump[ nJumpCount ]);
172 }
173 }
174 }
175 }
176 xNew = new ScJumpMatrixToken( pJumpMat );
177 GetTokenMatrixMap().emplace(pCur, xNew);
178 }
179 if (!xNew)
180 {
181 PushIllegalArgument();
182 return;
183 }
184 PushTokenRef( xNew);
185 // set endpoint of path for main code line
186 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
187 }
188 }
189 break;
190 default:
191 {
192 const bool bCondition = GetBool();
193 if (nGlobalError != FormulaError::NONE)
194 { // Propagate error, not THEN- or ELSE-path, jump behind.
195 PushError(nGlobalError);
196 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
197 }
198 else if ( bCondition )
199 { // TRUE
200 if( nJumpCount >= 2 )
201 { // THEN path
202 aCode.Jump( pJump[ 1 ], pJump[ nJumpCount ] );
203 }
204 else
205 { // no parameter given for THEN
206 nFuncFmtType = SvNumFormatType::LOGICAL;
207 PushInt(1);
208 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
209 }
210 }
211 else
212 { // FALSE
213 if( nJumpCount == 3 )
214 { // ELSE path
215 aCode.Jump( pJump[ 2 ], pJump[ nJumpCount ] );
216 }
217 else
218 { // no parameter given for ELSE
219 nFuncFmtType = SvNumFormatType::LOGICAL;
220 PushInt(0);
221 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
222 }
223 }
224 }
225 }
226 }
227
228 /** Store a matrix value in another matrix in the context of that other matrix
229 is the result matrix of a jump matrix. All arguments must be valid and are
230 not checked. */
231 static void lcl_storeJumpMatResult(
232 const ScMatrix* pMat, ScJumpMatrix* pJumpMat, SCSIZE nC, SCSIZE nR )
233 {
234 if ( pMat->IsValue( nC, nR ) )
235 {
236 double fVal = pMat->GetDouble( nC, nR );
237 pJumpMat->PutResultDouble( fVal, nC, nR );
238 }
239 else if ( pMat->IsEmpty( nC, nR ) )
240 {
241 pJumpMat->PutResultEmpty( nC, nR );
242 }
243 else
244 {
245 pJumpMat->PutResultString(pMat->GetString(nC, nR), nC, nR);
246 }
247 }
248
249 void ScInterpreter::ScIfError( bool bNAonly )
250 {
251 const short* pJump = pCur->GetJump();
252 short nJumpCount = pJump[ 0 ];
253 if (!sp || nJumpCount != 2)
254 {
255 // Reset nGlobalError here to not propagate the old error, if any.
256 nGlobalError = (sp ? FormulaError::ParameterExpected : FormulaError::UnknownStackVariable);
257 PushError( nGlobalError);
258 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
259 return;
260 }
261
262 FormulaConstTokenRef xToken( pStack[ sp - 1 ] );
263 bool bError = false;
264 FormulaError nOldGlobalError = nGlobalError;
265 nGlobalError = FormulaError::NONE;
266
267 MatrixJumpConditionToMatrix();
268 switch (GetStackType())
269 {
270 default:
271 Pop();
272 // Act on implicitly propagated error, if any.
273 if (nOldGlobalError != FormulaError::NONE)
274 nGlobalError = nOldGlobalError;
275 if (nGlobalError != FormulaError::NONE)
276 bError = true;
277 break;
278 case svError:
279 PopError();
280 bError = true;
281 break;
282 case svDoubleRef:
283 case svSingleRef:
284 {
285 ScAddress aAdr;
286 if (!PopDoubleRefOrSingleRef( aAdr))
287 bError = true;
288 else
289 {
290
291 ScRefCellValue aCell(mrDoc, aAdr);
292 nGlobalError = GetCellErrCode(aCell);
293 if (nGlobalError != FormulaError::NONE)
294 bError = true;
295 }
296 }
297 break;
298 case svExternalSingleRef:
299 case svExternalDoubleRef:
300 {
301 double fVal;
302 svl::SharedString aStr;
303 // Handles also existing jump matrix case and sets error on
304 // elements.
305 GetDoubleOrStringFromMatrix( fVal, aStr);
306 if (nGlobalError != FormulaError::NONE)
307 bError = true;
308 }
309 break;
310 case svMatrix:
311 {
312 const ScMatrixRef pMat = PopMatrix();
313 if (!pMat || (nGlobalError != FormulaError::NONE && (!bNAonly || nGlobalError == FormulaError::NotAvailable)))
314 {
315 bError = true;
316 break; // switch
317 }
318 // If the matrix has no queried error at all we can simply use
319 // it as result and don't need to bother with jump matrix.
320 SCSIZE nErrorCol = ::std::numeric_limits<SCSIZE>::max(),
321 nErrorRow = ::std::numeric_limits<SCSIZE>::max();
322 SCSIZE nCols, nRows;
323 pMat->GetDimensions( nCols, nRows );
324 if (nCols == 0 || nRows == 0)
325 {
326 bError = true;
327 break; // switch
328 }
329 for (SCSIZE nC=0; nC < nCols && !bError; ++nC)
330 {
331 for (SCSIZE nR=0; nR < nRows && !bError; ++nR)
332 {
333 FormulaError nErr = pMat->GetError( nC, nR );
334 if (nErr != FormulaError::NONE && (!bNAonly || nErr == FormulaError::NotAvailable))
335 {
336 bError = true;
337 nErrorCol = nC;
338 nErrorRow = nR;
339 }
340 }
341 }
342 if (!bError)
343 break; // switch, we're done and have the result
344
345 FormulaConstTokenRef xNew;
346 ScTokenMatrixMap::const_iterator aMapIter;
347 if ((aMapIter = maTokenMatrixMap.find( pCur)) != maTokenMatrixMap.end())
348 {
349 xNew = (*aMapIter).second;
350 }
351 else
352 {
353 const ScMatrix* pMatPtr = pMat.get();
354 std::shared_ptr<ScJumpMatrix> pJumpMat( std::make_shared<ScJumpMatrix>(
355 pCur->GetOpCode(), nCols, nRows));
356 // Init all jumps to no error to save single calls. Error
357 // is the exceptional condition.
358 const double fFlagResult = CreateDoubleError( FormulaError::JumpMatHasResult);
359 pJumpMat->SetAllJumps( fFlagResult, pJump[ nJumpCount ], pJump[ nJumpCount ] );
360 // Up to first error position simply store results, no need
361 // to evaluate error conditions again.
362 SCSIZE nC = 0, nR = 0;
363 for ( ; nC < nCols && (nC != nErrorCol || nR != nErrorRow); /*nop*/ )
364 {
365 for (nR = 0 ; nR < nRows && (nC != nErrorCol || nR != nErrorRow); ++nR)
366 {
367 lcl_storeJumpMatResult(pMatPtr, pJumpMat.get(), nC, nR);
368 }
369 if (nC != nErrorCol && nR != nErrorRow)
370 ++nC;
371 }
372 // Now the mixed cases.
373 for ( ; nC < nCols; ++nC)
374 {
375 for ( ; nR < nRows; ++nR)
376 {
377 FormulaError nErr = pMat->GetError( nC, nR );
378 if (nErr != FormulaError::NONE && (!bNAonly || nErr == FormulaError::NotAvailable))
379 { // TRUE, THEN path
380 pJumpMat->SetJump( nC, nR, 1.0, pJump[ 1 ], pJump[ nJumpCount ] );
381 }
382 else
383 { // FALSE, EMPTY path, store result instead
384 lcl_storeJumpMatResult(pMatPtr, pJumpMat.get(), nC, nR);
385 }
386 }
387 nR = 0;
388 }
389 xNew = new ScJumpMatrixToken( pJumpMat );
390 GetTokenMatrixMap().emplace( pCur, xNew );
391 }
392 nGlobalError = nOldGlobalError;
393 PushTokenRef( xNew );
394 // set endpoint of path for main code line
395 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
396 return;
397 }
398 break;
399 }
400
401 if (bError && (!bNAonly || nGlobalError == FormulaError::NotAvailable))
402 {
403 // error, calculate 2nd argument
404 nGlobalError = FormulaError::NONE;
405 aCode.Jump( pJump[ 1 ], pJump[ nJumpCount ] );
406 }
407 else
408 {
409 // no error, push 1st argument and continue
410 nGlobalError = nOldGlobalError;
411 PushTokenRef( xToken);
412 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
413 }
414 }
415
416 void ScInterpreter::ScChooseJump()
417 {
418 // We have to set a jump, if there was none chosen because of an error set
419 // it to endpoint.
420 bool bHaveJump = false;
421 const short* pJump = pCur->GetJump();
422 short nJumpCount = pJump[ 0 ];
423 MatrixJumpConditionToMatrix();
424 switch ( GetStackType() )
425 {
426 case svMatrix:
427 {
428 ScMatrixRef pMat = PopMatrix();
429 if ( !pMat )
430 PushIllegalParameter();
431 else
432 {
433 FormulaConstTokenRef xNew;
434 ScTokenMatrixMap::const_iterator aMapIter;
435 // DoubleError handled by JumpMatrix
436 pMat->SetErrorInterpreter( nullptr);
437 SCSIZE nCols, nRows;
438 pMat->GetDimensions( nCols, nRows );
439 if ( nCols == 0 || nRows == 0 )
440 PushIllegalParameter();
441 else if ((aMapIter = maTokenMatrixMap.find(
442 pCur)) != maTokenMatrixMap.end())
443 xNew = (*aMapIter).second;
444 else
445 {
446 std::shared_ptr<ScJumpMatrix> pJumpMat( std::make_shared<ScJumpMatrix>(
447 pCur->GetOpCode(), nCols, nRows));
448 for ( SCSIZE nC=0; nC < nCols; ++nC )
449 {
450 for ( SCSIZE nR=0; nR < nRows; ++nR )
451 {
452 double fVal;
453 bool bIsValue = pMat->IsValue(nC, nR);
454 if ( bIsValue )
455 {
456 fVal = pMat->GetDouble(nC, nR);
457 bIsValue = std::isfinite( fVal );
458 if ( bIsValue )
459 {
460 fVal = ::rtl::math::approxFloor( fVal);
461 if ( (fVal < 1) || (fVal >= nJumpCount))
462 {
463 bIsValue = false;
464 fVal = CreateDoubleError(
465 FormulaError::IllegalArgument);
466 }
467 }
468 }
469 else
470 {
471 fVal = CreateDoubleError( FormulaError::NoValue);
472 }
473 if ( bIsValue )
474 {
475 pJumpMat->SetJump( nC, nR, fVal,
476 pJump[ static_cast<short>(fVal) ],
477 pJump[ nJumpCount ]);
478 }
479 else
480 {
481 pJumpMat->SetJump( nC, nR, fVal,
482 pJump[ nJumpCount ],
483 pJump[ nJumpCount ]);
484 }
485 }
486 }
487 xNew = new ScJumpMatrixToken( pJumpMat );
488 GetTokenMatrixMap().emplace(pCur, xNew);
489 }
490 if (xNew)
491 {
492 PushTokenRef( xNew);
493 // set endpoint of path for main code line
494 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
495 bHaveJump = true;
496 }
497 }
498 }
499 break;
500 default:
501 {
502 sal_Int16 nJumpIndex = GetInt16();
503 if (nGlobalError == FormulaError::NONE && (nJumpIndex >= 1) && (nJumpIndex < nJumpCount))
504 {
505 aCode.Jump( pJump[ static_cast<short>(nJumpIndex) ], pJump[ nJumpCount ] );
506 bHaveJump = true;
507 }
508 else
509 PushIllegalArgument();
510 }
511 }
512 if (!bHaveJump)
513 aCode.Jump( pJump[ nJumpCount ], pJump[ nJumpCount ] );
514 }
515
516 static void lcl_AdjustJumpMatrix( ScJumpMatrix* pJumpM, SCSIZE nParmCols, SCSIZE nParmRows )
517 {
518 SCSIZE nJumpCols, nJumpRows;
519 SCSIZE nResCols, nResRows;
520 SCSIZE nAdjustCols, nAdjustRows;
521 pJumpM->GetDimensions( nJumpCols, nJumpRows );
522 pJumpM->GetResMatDimensions( nResCols, nResRows );
523 if (!(( nJumpCols == 1 && nParmCols > nResCols ) ||
524 ( nJumpRows == 1 && nParmRows > nResRows )))
525 return;
526
527 if ( nJumpCols == 1 && nJumpRows == 1 )
528 {
529 nAdjustCols = std::max(nParmCols, nResCols);
530 nAdjustRows = std::max(nParmRows, nResRows);
531 }
532 else if ( nJumpCols == 1 )
533 {
534 nAdjustCols = nParmCols;
535 nAdjustRows = nResRows;
536 }
537 else
538 {
539 nAdjustCols = nResCols;
540 nAdjustRows = nParmRows;
541 }
542 pJumpM->SetNewResMat( nAdjustCols, nAdjustRows );
543 }
544
545 bool ScInterpreter::JumpMatrix( short nStackLevel )
546 {
547 pJumpMatrix = pStack[sp-nStackLevel]->GetJumpMatrix();
548 bool bHasResMat = pJumpMatrix->HasResultMatrix();
549 SCSIZE nC, nR;
550 if ( nStackLevel == 2 )
551 {
552 if ( aCode.HasStacked() )
553 aCode.Pop(); // pop what Jump() pushed
554 else
555 {
556 assert(!"pop goes the weasel");
557 }
558
559 if ( !bHasResMat )
560 {
561 Pop();
562 SetError( FormulaError::UnknownStackVariable );
563 }
564 else
565 {
566 pJumpMatrix->GetPos( nC, nR );
567 switch ( GetStackType() )
568 {
569 case svDouble:
570 {
571 double fVal = GetDouble();
572 if ( nGlobalError != FormulaError::NONE )
573 {
574 fVal = CreateDoubleError( nGlobalError );
575 nGlobalError = FormulaError::NONE;
576 }
577 pJumpMatrix->PutResultDouble( fVal, nC, nR );
578 }
579 break;
580 case svString:
581 {
582 svl::SharedString aStr = GetString();
583 if ( nGlobalError != FormulaError::NONE )
584 {
585 pJumpMatrix->PutResultDouble( CreateDoubleError( nGlobalError),
586 nC, nR);
587 nGlobalError = FormulaError::NONE;
588 }
589 else
590 pJumpMatrix->PutResultString(aStr, nC, nR);
591 }
592 break;
593 case svSingleRef:
594 {
595 FormulaConstTokenRef xRef = pStack[sp-1];
596 ScAddress aAdr;
597 PopSingleRef( aAdr );
598 if ( nGlobalError != FormulaError::NONE )
599 {
600 pJumpMatrix->PutResultDouble( CreateDoubleError( nGlobalError),
601 nC, nR);
602 nGlobalError = FormulaError::NONE;
603 }
604 else
605 {
606 ScRefCellValue aCell(mrDoc, aAdr);
607 if (aCell.hasEmptyValue())
608 pJumpMatrix->PutResultEmpty( nC, nR );
609 else if (aCell.hasNumeric())
610 {
611 double fVal = GetCellValue(aAdr, aCell);
612 if ( nGlobalError != FormulaError::NONE )
613 {
614 fVal = CreateDoubleError(
615 nGlobalError);
616 nGlobalError = FormulaError::NONE;
617 }
618 pJumpMatrix->PutResultDouble( fVal, nC, nR );
619 }
620 else
621 {
622 svl::SharedString aStr;
623 GetCellString(aStr, aCell);
624 if ( nGlobalError != FormulaError::NONE )
625 {
626 pJumpMatrix->PutResultDouble( CreateDoubleError(
627 nGlobalError), nC, nR);
628 nGlobalError = FormulaError::NONE;
629 }
630 else
631 pJumpMatrix->PutResultString(aStr, nC, nR);
632 }
633 }
634
635 formula::ParamClass eReturnType = ScParameterClassification::GetParameterType( pCur, SAL_MAX_UINT16);
636 if (eReturnType == ParamClass::Reference)
637 {
638 /* TODO: What about error handling and do we actually
639 * need the result matrix above at all in this case? */
640 ScComplexRefData aRef;
641 aRef.Ref1 = aRef.Ref2 = *(xRef->GetSingleRef());
642 pJumpMatrix->GetRefList().push_back( aRef);
643 }
644 }
645 break;
646 case svDoubleRef:
647 { // upper left plus offset within matrix
648 FormulaConstTokenRef xRef = pStack[sp-1];
649 double fVal;
650 ScRange aRange;
651 PopDoubleRef( aRange );
652 if ( nGlobalError != FormulaError::NONE )
653 {
654 fVal = CreateDoubleError( nGlobalError );
655 nGlobalError = FormulaError::NONE;
656 pJumpMatrix->PutResultDouble( fVal, nC, nR );
657 }
658 else
659 {
660 // Do not modify the original range because we use it
661 // to adjust the size of the result matrix if necessary.
662 ScAddress aAdr( aRange.aStart);
663 sal_uLong nCol = static_cast<sal_uLong>(aAdr.Col()) + nC;
664 sal_uLong nRow = static_cast<sal_uLong>(aAdr.Row()) + nR;
665 if ((nCol > o3tl::make_unsigned(aRange.aEnd.Col()) &&
666 aRange.aEnd.Col() != aRange.aStart.Col())
667 || (nRow > o3tl::make_unsigned(aRange.aEnd.Row()) &&
668 aRange.aEnd.Row() != aRange.aStart.Row()))
669 {
670 fVal = CreateDoubleError( FormulaError::NotAvailable );
671 pJumpMatrix->PutResultDouble( fVal, nC, nR );
672 }
673 else
674 {
675 // Replicate column and/or row of a vector if it is
676 // one. Note that this could be a range reference
677 // that in fact consists of only one cell, e.g. A1:A1
678 if (aRange.aEnd.Col() == aRange.aStart.Col())
679 nCol = aRange.aStart.Col();
680 if (aRange.aEnd.Row() == aRange.aStart.Row())
681 nRow = aRange.aStart.Row();
682 aAdr.SetCol( static_cast<SCCOL>(nCol) );
683 aAdr.SetRow( static_cast<SCROW>(nRow) );
684 ScRefCellValue aCell(mrDoc, aAdr);
685 if (aCell.hasEmptyValue())
686 pJumpMatrix->PutResultEmpty( nC, nR );
687 else if (aCell.hasNumeric())
688 {
689 double fCellVal = GetCellValue(aAdr, aCell);
690 if ( nGlobalError != FormulaError::NONE )
691 {
692 fCellVal = CreateDoubleError(
693 nGlobalError);
694 nGlobalError = FormulaError::NONE;
695 }
696 pJumpMatrix->PutResultDouble( fCellVal, nC, nR );
697 }
698 else
699 {
700 svl::SharedString aStr;
701 GetCellString(aStr, aCell);
702 if ( nGlobalError != FormulaError::NONE )
703 {
704 pJumpMatrix->PutResultDouble( CreateDoubleError(
705 nGlobalError), nC, nR);
706 nGlobalError = FormulaError::NONE;
707 }
708 else
709 pJumpMatrix->PutResultString(aStr, nC, nR);
710 }
711 }
712 SCSIZE nParmCols = aRange.aEnd.Col() - aRange.aStart.Col() + 1;
713 SCSIZE nParmRows = aRange.aEnd.Row() - aRange.aStart.Row() + 1;
714 lcl_AdjustJumpMatrix( pJumpMatrix, nParmCols, nParmRows );
715 }
716
717 formula::ParamClass eReturnType = ScParameterClassification::GetParameterType( pCur, SAL_MAX_UINT16);
718 if (eReturnType == ParamClass::Reference)
719 {
720 /* TODO: What about error handling and do we actually
721 * need the result matrix above at all in this case? */
722 pJumpMatrix->GetRefList().push_back( *(xRef->GetDoubleRef()));
723 }
724 }
725 break;
726 case svExternalSingleRef:
727 {
728 ScExternalRefCache::TokenRef pToken;
729 PopExternalSingleRef(pToken);
730 if (nGlobalError != FormulaError::NONE)
731 {
732 pJumpMatrix->PutResultDouble( CreateDoubleError( nGlobalError), nC, nR );
733 nGlobalError = FormulaError::NONE;
734 }
735 else
736 {
737 switch (pToken->GetType())
738 {
739 case svDouble:
740 pJumpMatrix->PutResultDouble( pToken->GetDouble(), nC, nR );
741 break;
742 case svString:
743 pJumpMatrix->PutResultString( pToken->GetString(), nC, nR );
744 break;
745 case svEmptyCell:
746 pJumpMatrix->PutResultEmpty( nC, nR );
747 break;
748 default:
749 // svError was already handled (set by
750 // PopExternalSingleRef()) with nGlobalError
751 // above.
752 assert(!"unhandled svExternalSingleRef case");
753 pJumpMatrix->PutResultDouble( CreateDoubleError(
754 FormulaError::UnknownStackVariable), nC, nR );
755 }
756 }
757 }
758 break;
759 case svExternalDoubleRef:
760 case svMatrix:
761 { // match matrix offsets
762 double fVal;
763 ScMatrixRef pMat = GetMatrix();
764 if ( nGlobalError != FormulaError::NONE )
765 {
766 fVal = CreateDoubleError( nGlobalError );
767 nGlobalError = FormulaError::NONE;
768 pJumpMatrix->PutResultDouble( fVal, nC, nR );
769 }
770 else if ( !pMat )
771 {
772 fVal = CreateDoubleError( FormulaError::UnknownVariable );
773 pJumpMatrix->PutResultDouble( fVal, nC, nR );
774 }
775 else
776 {
777 SCSIZE nCols, nRows;
778 pMat->GetDimensions( nCols, nRows );
779 if ((nCols <= nC && nCols != 1) ||
780 (nRows <= nR && nRows != 1))
781 {
782 fVal = CreateDoubleError( FormulaError::NotAvailable );
783 pJumpMatrix->PutResultDouble( fVal, nC, nR );
784 }
785 else
786 {
787 // GetMatrix() does SetErrorInterpreter() at the
788 // matrix, do not propagate an error from
789 // matrix->GetValue() as global error.
790 pMat->SetErrorInterpreter(nullptr);
791 lcl_storeJumpMatResult(pMat.get(), pJumpMatrix, nC, nR);
792 }
793 lcl_AdjustJumpMatrix( pJumpMatrix, nCols, nRows );
794 }
795 }
796 break;
797 case svError:
798 {
799 PopError();
800 double fVal = CreateDoubleError( nGlobalError);
801 nGlobalError = FormulaError::NONE;
802 pJumpMatrix->PutResultDouble( fVal, nC, nR );
803 }
804 break;
805 default:
806 {
807 Pop();
808 double fVal = CreateDoubleError( FormulaError::IllegalArgument);
809 pJumpMatrix->PutResultDouble( fVal, nC, nR );
810 }
811 }
812 }
813 }
814 bool bCont = pJumpMatrix->Next( nC, nR );
815 if ( bCont )
816 {
817 double fBool;
818 short nStart, nNext, nStop;
819 pJumpMatrix->GetJump( nC, nR, fBool, nStart, nNext, nStop );
820 while ( bCont && nStart == nNext )
821 { // push all results that have no jump path
822 if ( bHasResMat && (GetDoubleErrorValue( fBool) != FormulaError::JumpMatHasResult) )
823 {
824 // a false without path results in an empty path value
825 if ( fBool == 0.0 )
826 pJumpMatrix->PutResultEmptyPath( nC, nR );
827 else
828 pJumpMatrix->PutResultDouble( fBool, nC, nR );
829 }
830 bCont = pJumpMatrix->Next( nC, nR );
831 if ( bCont )
832 pJumpMatrix->GetJump( nC, nR, fBool, nStart, nNext, nStop );
833 }
834 if ( bCont && nStart != nNext )
835 {
836 const ScTokenVec & rParams = pJumpMatrix->GetJumpParameters();
837 for ( auto const & i : rParams )
838 {
839 // This is not the current state of the interpreter, so
840 // push without error, and elements' errors are coded into
841 // double.
842 PushWithoutError(*i);
843 }
844 aCode.Jump( nStart, nNext, nStop );
845 }
846 }
847 if ( !bCont )
848 { // We're done with it, throw away jump matrix, keep result.
849 // For an intermediate result of Reference use the array of references
850 // if there are more than one reference and the current ForceArray
851 // context is ReferenceOrRefArray.
852 // Else (also for a final result of Reference) use the matrix.
853 // Treat the result of a jump command as final and use the matrix (see
854 // tdf#115493 for why).
855 if (pCur->GetInForceArray() == ParamClass::ReferenceOrRefArray &&
856 pJumpMatrix->GetRefList().size() > 1 &&
857 ScParameterClassification::GetParameterType( pCur, SAL_MAX_UINT16) == ParamClass::Reference &&
858 !FormulaCompiler::IsOpCodeJumpCommand( pJumpMatrix->GetOpCode()) &&
859 aCode.PeekNextOperator())
860 {
861 FormulaTokenRef xRef = new ScRefListToken(true);
862 *(xRef->GetRefList()) = pJumpMatrix->GetRefList();
863 pJumpMatrix = nullptr;
864 Pop();
865 PushTokenRef( xRef);
866 maTokenMatrixMap.erase( pCur);
867 // There's no result matrix to remember in this case.
868 }
869 else
870 {
871 ScMatrix* pResMat = pJumpMatrix->GetResultMatrix();
872 pJumpMatrix = nullptr;
873 Pop();
874 PushMatrix( pResMat );
875 // Remove jump matrix from map and remember result matrix in case it
876 // could be reused in another path of the same condition.
877 maTokenMatrixMap.erase( pCur);
878 maTokenMatrixMap.emplace(pCur, pStack[sp-1]);
879 }
880 return true;
881 }
882 return false;
883 }
884
885 double ScInterpreter::Compare( ScQueryOp eOp )
886 {
887 sc::Compare aComp;
888 aComp.meOp = eOp;
889 aComp.mbIgnoreCase = mrDoc.GetDocOptions().IsIgnoreCase();
890 for( short i = 1; i >= 0; i-- )
891 {
892 sc::Compare::Cell& rCell = aComp.maCells[i];
893
894 switch ( GetRawStackType() )
895 {
896 case svEmptyCell:
897 Pop();
898 rCell.mbEmpty = true;
899 break;
900 case svMissing:
901 case svDouble:
902 rCell.mfValue = GetDouble();
903 rCell.mbValue = true;
904 break;
905 case svString:
906 rCell.maStr = GetString();
907 rCell.mbValue = false;
908 break;
909 case svDoubleRef :
910 case svSingleRef :
911 {
912 ScAddress aAdr;
913 if ( !PopDoubleRefOrSingleRef( aAdr ) )
914 break;
915 ScRefCellValue aCell(mrDoc, aAdr);
916 if (aCell.hasEmptyValue())
917 rCell.mbEmpty = true;
918 else if (aCell.hasString())
919 {
920 svl::SharedString aStr;
921 GetCellString(aStr, aCell);
922 rCell.maStr = aStr;
923 rCell.mbValue = false;
924 }
925 else
926 {
927 rCell.mfValue = GetCellValue(aAdr, aCell);
928 rCell.mbValue = true;
929 }
930 }
931 break;
932 case svExternalSingleRef:
933 {
934 ScMatrixRef pMat = GetMatrix();
935 if (!pMat)
936 {
937 SetError( FormulaError::IllegalParameter);
938 break;
939 }
940
941 SCSIZE nC, nR;
942 pMat->GetDimensions(nC, nR);
943 if (!nC || !nR)
944 {
945 SetError( FormulaError::IllegalParameter);
946 break;
947 }
948 if (pMat->IsEmpty(0, 0))
949 rCell.mbEmpty = true;
950 else if (pMat->IsStringOrEmpty(0, 0))
951 {
952 rCell.maStr = pMat->GetString(0, 0);
953 rCell.mbValue = false;
954 }
955 else
956 {
957 rCell.mfValue = pMat->GetDouble(0, 0);
958 rCell.mbValue = true;
959 }
960 }
961 break;
962 case svExternalDoubleRef:
963 // TODO: Find out how to handle this...
964 // Xcl generates a position dependent intersection using
965 // col/row, as it seems to do for all range references, not
966 // only in compare context. We'd need a general implementation
967 // for that behavior similar to svDoubleRef in scalar and array
968 // mode. Which also means we'd have to change all places where
969 // it currently is handled along with svMatrix.
970 default:
971 PopError();
972 SetError( FormulaError::IllegalParameter);
973 break;
974 }
975 }
976 if( nGlobalError != FormulaError::NONE )
977 return 0;
978 nCurFmtType = nFuncFmtType = SvNumFormatType::LOGICAL;
979 return sc::CompareFunc(aComp);
980 }
981
982 sc::RangeMatrix ScInterpreter::CompareMat( ScQueryOp eOp, sc::CompareOptions* pOptions )
983 {
984 sc::Compare aComp;
985 aComp.meOp = eOp;
986 aComp.mbIgnoreCase = mrDoc.GetDocOptions().IsIgnoreCase();
987 sc::RangeMatrix aMat[2];
988 ScAddress aAdr;
989 for( short i = 1; i >= 0; i-- )
990 {
991 sc::Compare::Cell& rCell = aComp.maCells[i];
992
993 switch (GetRawStackType())
994 {
995 case svEmptyCell:
996 Pop();
997 rCell.mbEmpty = true;
998 break;
999 case svMissing:
1000 case svDouble:
1001 rCell.mfValue = GetDouble();
1002 rCell.mbValue = true;
1003 break;
1004 case svString:
1005 rCell.maStr = GetString();
1006 rCell.mbValue = false;
1007 break;
1008 case svSingleRef:
1009 {
1010 PopSingleRef( aAdr );
1011 ScRefCellValue aCell(mrDoc, aAdr);
1012 if (aCell.hasEmptyValue())
1013 rCell.mbEmpty = true;
1014 else if (aCell.hasString())
1015 {
1016 svl::SharedString aStr;
1017 GetCellString(aStr, aCell);
1018 rCell.maStr = aStr;
1019 rCell.mbValue = false;
1020 }
1021 else
1022 {
1023 rCell.mfValue = GetCellValue(aAdr, aCell);
1024 rCell.mbValue = true;
1025 }
1026 }
1027 break;
1028 case svExternalSingleRef:
1029 case svExternalDoubleRef:
1030 case svDoubleRef:
1031 case svMatrix:
1032 aMat[i] = GetRangeMatrix();
1033 if (!aMat[i].mpMat)
1034 SetError( FormulaError::IllegalParameter);
1035 else
1036 aMat[i].mpMat->SetErrorInterpreter(nullptr);
1037 // errors are transported as DoubleError inside matrix
1038 break;
1039 default:
1040 PopError();
1041 SetError( FormulaError::IllegalParameter);
1042 break;
1043 }
1044 }
1045
1046 sc::RangeMatrix aRes;
1047
1048 if (nGlobalError != FormulaError::NONE)
1049 {
1050 nCurFmtType = nFuncFmtType = SvNumFormatType::LOGICAL;
1051 return aRes;
1052 }
1053
1054 if (aMat[0].mpMat && aMat[1].mpMat)
1055 {
1056 SCSIZE nC0, nC1;
1057 SCSIZE nR0, nR1;
1058 aMat[0].mpMat->GetDimensions(nC0, nR0);
1059 aMat[1].mpMat->GetDimensions(nC1, nR1);
1060 SCSIZE nC = std::max( nC0, nC1 );
1061 SCSIZE nR = std::max( nR0, nR1 );
1062 aRes.mpMat = GetNewMat( nC, nR, /*bEmpty*/true );
1063 if (!aRes.mpMat)
1064 return aRes;
1065 for ( SCSIZE j=0; j<nC; j++ )
1066 {
1067 for ( SCSIZE k=0; k<nR; k++ )
1068 {
1069 SCSIZE nCol = j, nRow = k;
1070 if (aMat[0].mpMat->ValidColRowOrReplicated(nCol, nRow) &&
1071 aMat[1].mpMat->ValidColRowOrReplicated(nCol, nRow))
1072 {
1073 for ( short i=1; i>=0; i-- )
1074 {
1075 sc::Compare::Cell& rCell = aComp.maCells[i];
1076
1077 if (aMat[i].mpMat->IsStringOrEmpty(j, k))
1078 {
1079 rCell.mbValue = false;
1080 rCell.maStr = aMat[i].mpMat->GetString(j, k);
1081 rCell.mbEmpty = aMat[i].mpMat->IsEmpty(j, k);
1082 }
1083 else
1084 {
1085 rCell.mbValue = true;
1086 rCell.mfValue = aMat[i].mpMat->GetDouble(j, k);
1087 rCell.mbEmpty = false;
1088 }
1089 }
1090 aRes.mpMat->PutDouble( sc::CompareFunc( aComp, pOptions), j, k);
1091 }
1092 else
1093 aRes.mpMat->PutError( FormulaError::NoValue, j, k);
1094 }
1095 }
1096
1097 switch (eOp)
1098 {
1099 case SC_EQUAL:
1100 aRes.mpMat->CompareEqual();
1101 break;
1102 case SC_LESS:
1103 aRes.mpMat->CompareLess();
1104 break;
1105 case SC_GREATER:
1106 aRes.mpMat->CompareGreater();
1107 break;
1108 case SC_LESS_EQUAL:
1109 aRes.mpMat->CompareLessEqual();
1110 break;
1111 case SC_GREATER_EQUAL:
1112 aRes.mpMat->CompareGreaterEqual();
1113 break;
1114 case SC_NOT_EQUAL:
1115 aRes.mpMat->CompareNotEqual();
1116 break;
1117 default:
1118 SAL_WARN("sc", "ScInterpreter::QueryMat: unhandled comparison operator: " << static_cast<int>(eOp));
1119 aRes.mpMat.reset();
1120 return aRes;
1121 }
1122 }
1123 else if (aMat[0].mpMat || aMat[1].mpMat)
1124 {
1125 size_t i = ( aMat[0].mpMat ? 0 : 1);
1126
1127 aRes.mnCol1 = aMat[i].mnCol1;
1128 aRes.mnRow1 = aMat[i].mnRow1;
1129 aRes.mnTab1 = aMat[i].mnTab1;
1130 aRes.mnCol2 = aMat[i].mnCol2;
1131 aRes.mnRow2 = aMat[i].mnRow2;
1132 aRes.mnTab2 = aMat[i].mnTab2;
1133
1134 ScMatrix& rMat = *aMat[i].mpMat;
1135 aRes.mpMat = rMat.CompareMatrix(aComp, i, pOptions);
1136 if (!aRes.mpMat)
1137 return aRes;
1138 }
1139
1140 nCurFmtType = nFuncFmtType = SvNumFormatType::LOGICAL;
1141 return aRes;
1142 }
1143
1144 ScMatrixRef ScInterpreter::QueryMat( const ScMatrixRef& pMat, sc::CompareOptions& rOptions )
1145 {
1146 SvNumFormatType nSaveCurFmtType = nCurFmtType;
1147 SvNumFormatType nSaveFuncFmtType = nFuncFmtType;
1148 PushMatrix( pMat);
1149 const ScQueryEntry::Item& rItem = rOptions.aQueryEntry.GetQueryItem();
1150 if (rItem.meType == ScQueryEntry::ByString)
1151 PushString(rItem.maString.getString());
1152 else
1153 PushDouble(rItem.mfVal);
1154 ScMatrixRef pResultMatrix = CompareMat(rOptions.aQueryEntry.eOp, &rOptions).mpMat;
1155 nCurFmtType = nSaveCurFmtType;
1156 nFuncFmtType = nSaveFuncFmtType;
1157 if (nGlobalError != FormulaError::NONE || !pResultMatrix)
1158 {
1159 SetError( FormulaError::IllegalParameter);
1160 return pResultMatrix;
1161 }
1162
1163 return pResultMatrix;
1164 }
1165
1166 void ScInterpreter::ScEqual()
1167 {
1168 if ( GetStackType(1) == svMatrix || GetStackType(2) == svMatrix )
1169 {
1170 sc::RangeMatrix aMat = CompareMat(SC_EQUAL);
1171 if (!aMat.mpMat)
1172 {
1173 PushIllegalParameter();
1174 return;
1175 }
1176
1177 PushMatrix(aMat);
1178 }
1179 else
1180 PushInt( int(Compare( SC_EQUAL) == 0) );
1181 }
1182
1183 void ScInterpreter::ScNotEqual()
1184 {
1185 if ( GetStackType(1) == svMatrix || GetStackType(2) == svMatrix )
1186 {
1187 sc::RangeMatrix aMat = CompareMat(SC_NOT_EQUAL);
1188 if (!aMat.mpMat)
1189 {
1190 PushIllegalParameter();
1191 return;
1192 }
1193
1194 PushMatrix(aMat);
1195 }
1196 else
1197 PushInt( int(Compare( SC_NOT_EQUAL) != 0) );
1198 }
1199
1200 void ScInterpreter::ScLess()
1201 {
1202 if ( GetStackType(1) == svMatrix || GetStackType(2) == svMatrix )
1203 {
1204 sc::RangeMatrix aMat = CompareMat(SC_LESS);
1205 if (!aMat.mpMat)
1206 {
1207 PushIllegalParameter();
1208 return;
1209 }
1210
1211 PushMatrix(aMat);
1212 }
1213 else
1214 PushInt( int(Compare( SC_LESS) < 0) );
1215 }
1216
1217 void ScInterpreter::ScGreater()
1218 {
1219 if ( GetStackType(1) == svMatrix || GetStackType(2) == svMatrix )
1220 {
1221 sc::RangeMatrix aMat = CompareMat(SC_GREATER);
1222 if (!aMat.mpMat)
1223 {
1224 PushIllegalParameter();
1225 return;
1226 }
1227
1228 PushMatrix(aMat);
1229 }
1230 else
1231 PushInt( int(Compare( SC_GREATER) > 0) );
1232 }
1233
1234 void ScInterpreter::ScLessEqual()
1235 {
1236 if ( GetStackType(1) == svMatrix || GetStackType(2) == svMatrix )
1237 {
1238 sc::RangeMatrix aMat = CompareMat(SC_LESS_EQUAL);
1239 if (!aMat.mpMat)
1240 {
1241 PushIllegalParameter();
1242 return;
1243 }
1244
1245 PushMatrix(aMat);
1246 }
1247 else
1248 PushInt( int(Compare( SC_LESS_EQUAL) <= 0) );
1249 }
1250
1251 void ScInterpreter::ScGreaterEqual()
1252 {
1253 if ( GetStackType(1) == svMatrix || GetStackType(2) == svMatrix )
1254 {
1255 sc::RangeMatrix aMat = CompareMat(SC_GREATER_EQUAL);
1256 if (!aMat.mpMat)
1257 {
1258 PushIllegalParameter();
1259 return;
1260 }
1261
1262 PushMatrix(aMat);
1263 }
1264 else
1265 PushInt( int(Compare( SC_GREATER_EQUAL) >= 0) );
1266 }
1267
1268 void ScInterpreter::ScAnd()
1269 {
1270 nFuncFmtType = SvNumFormatType::LOGICAL;
1271 short nParamCount = GetByte();
1272 if ( !MustHaveParamCountMin( nParamCount, 1 ) )
1273 return;
1274
1275 bool bHaveValue = false;
1276 bool bRes = true;
1277 size_t nRefInList = 0;
1278 while( nParamCount-- > 0)
1279 {
1280 if ( nGlobalError == FormulaError::NONE )
1281 {
1282 switch ( GetStackType() )
1283 {
1284 case svDouble :
1285 bHaveValue = true;
1286 bRes &= ( PopDouble() != 0.0 );
1287 break;
1288 case svString :
1289 Pop();
1290 SetError( FormulaError::NoValue );
1291 break;
1292 case svSingleRef :
1293 {
1294 ScAddress aAdr;
1295 PopSingleRef( aAdr );
1296 if ( nGlobalError == FormulaError::NONE )
1297 {
1298 ScRefCellValue aCell(mrDoc, aAdr);
1299 if (aCell.hasNumeric())
1300 {
1301 bHaveValue = true;
1302 bRes &= ( GetCellValue(aAdr, aCell) != 0.0 );
1303 }
1304 // else: Xcl raises no error here
1305 }
1306 }
1307 break;
1308 case svDoubleRef:
1309 case svRefList:
1310 {
1311 ScRange aRange;
1312 PopDoubleRef( aRange, nParamCount, nRefInList);
1313 if ( nGlobalError == FormulaError::NONE )
1314 {
1315 double fVal;
1316 FormulaError nErr = FormulaError::NONE;
1317 ScValueIterator aValIter( mrContext, aRange );
1318 if ( aValIter.GetFirst( fVal, nErr ) && nErr == FormulaError::NONE )
1319 {
1320 bHaveValue = true;
1321 do
1322 {
1323 bRes &= ( fVal != 0.0 );
1324 } while ( (nErr == FormulaError::NONE) &&
1325 aValIter.GetNext( fVal, nErr ) );
1326 }
1327 SetError( nErr );
1328 }
1329 }
1330 break;
1331 case svExternalSingleRef:
1332 case svExternalDoubleRef:
1333 case svMatrix:
1334 {
1335 ScMatrixRef pMat = GetMatrix();
1336 if ( pMat )
1337 {
1338 bHaveValue = true;
1339 double fVal = pMat->And();
1340 FormulaError nErr = GetDoubleErrorValue( fVal );
1341 if ( nErr != FormulaError::NONE )
1342 {
1343 SetError( nErr );
1344 bRes = false;
1345 }
1346 else
1347 bRes &= (fVal != 0.0);
1348 }
1349 // else: GetMatrix did set FormulaError::IllegalParameter
1350 }
1351 break;
1352 default:
1353 PopError();
1354 SetError( FormulaError::IllegalParameter);
1355 }
1356 }
1357 else
1358 Pop();
1359 }
1360 if ( bHaveValue )
1361 PushInt( int(bRes) );
1362 else
1363 PushNoValue();
1364 }
1365
1366 void ScInterpreter::ScOr()
1367 {
1368 nFuncFmtType = SvNumFormatType::LOGICAL;
1369 short nParamCount = GetByte();
1370 if ( !MustHaveParamCountMin( nParamCount, 1 ) )
1371 return;
1372
1373 bool bHaveValue = false;
1374 bool bRes = false;
1375 size_t nRefInList = 0;
1376 while( nParamCount-- > 0)
1377 {
1378 if ( nGlobalError == FormulaError::NONE )
1379 {
1380 switch ( GetStackType() )
1381 {
1382 case svDouble :
1383 bHaveValue = true;
1384 bRes |= ( PopDouble() != 0.0 );
1385 break;
1386 case svString :
1387 Pop();
1388 SetError( FormulaError::NoValue );
1389 break;
1390 case svSingleRef :
1391 {
1392 ScAddress aAdr;
1393 PopSingleRef( aAdr );
1394 if ( nGlobalError == FormulaError::NONE )
1395 {
1396 ScRefCellValue aCell(mrDoc, aAdr);
1397 if (aCell.hasNumeric())
1398 {
1399 bHaveValue = true;
1400 bRes |= ( GetCellValue(aAdr, aCell) != 0.0 );
1401 }
1402 // else: Xcl raises no error here
1403 }
1404 }
1405 break;
1406 case svDoubleRef:
1407 case svRefList:
1408 {
1409 ScRange aRange;
1410 PopDoubleRef( aRange, nParamCount, nRefInList);
1411 if ( nGlobalError == FormulaError::NONE )
1412 {
1413 double fVal;
1414 FormulaError nErr = FormulaError::NONE;
1415 ScValueIterator aValIter( mrContext, aRange );
1416 if ( aValIter.GetFirst( fVal, nErr ) )
1417 {
1418 bHaveValue = true;
1419 do
1420 {
1421 bRes |= ( fVal != 0.0 );
1422 } while ( (nErr == FormulaError::NONE) &&
1423 aValIter.GetNext( fVal, nErr ) );
1424 }
1425 SetError( nErr );
1426 }
1427 }
1428 break;
1429 case svExternalSingleRef:
1430 case svExternalDoubleRef:
1431 case svMatrix:
1432 {
1433 bHaveValue = true;
1434 ScMatrixRef pMat = GetMatrix();
1435 if ( pMat )
1436 {
1437 bHaveValue = true;
1438 double fVal = pMat->Or();
1439 FormulaError nErr = GetDoubleErrorValue( fVal );
1440 if ( nErr != FormulaError::NONE )
1441 {
1442 SetError( nErr );
1443 bRes = false;
1444 }
1445 else
1446 bRes |= (fVal != 0.0);
1447 }
1448 // else: GetMatrix did set FormulaError::IllegalParameter
1449 }
1450 break;
1451 default:
1452 PopError();
1453 SetError( FormulaError::IllegalParameter);
1454 }
1455 }
1456 else
1457 Pop();
1458 }
1459 if ( bHaveValue )
1460 PushInt( int(bRes) );
1461 else
1462 PushNoValue();
1463 }
1464
1465 void ScInterpreter::ScXor()
1466 {
1467
1468 nFuncFmtType = SvNumFormatType::LOGICAL;
1469 short nParamCount = GetByte();
1470 if ( !MustHaveParamCountMin( nParamCount, 1 ) )
1471 return;
1472
1473 bool bHaveValue = false;
1474 bool bRes = false;
1475 size_t nRefInList = 0;
1476 while( nParamCount-- > 0)
1477 {
1478 if ( nGlobalError == FormulaError::NONE )
1479 {
1480 switch ( GetStackType() )
1481 {
1482 case svDouble :
1483 bHaveValue = true;
1484 bRes ^= ( PopDouble() != 0.0 );
1485 break;
1486 case svString :
1487 Pop();
1488 SetError( FormulaError::NoValue );
1489 break;
1490 case svSingleRef :
1491 {
1492 ScAddress aAdr;
1493 PopSingleRef( aAdr );
1494 if ( nGlobalError == FormulaError::NONE )
1495 {
1496 ScRefCellValue aCell(mrDoc, aAdr);
1497 if (aCell.hasNumeric())
1498 {
1499 bHaveValue = true;
1500 bRes ^= ( GetCellValue(aAdr, aCell) != 0.0 );
1501 }
1502 /* TODO: set error? Excel doesn't have XOR, but
1503 * doesn't set an error in this case for AND and
1504 * OR. */
1505 }
1506 }
1507 break;
1508 case svDoubleRef:
1509 case svRefList:
1510 {
1511 ScRange aRange;
1512 PopDoubleRef( aRange, nParamCount, nRefInList);
1513 if ( nGlobalError == FormulaError::NONE )
1514 {
1515 double fVal;
1516 FormulaError nErr = FormulaError::NONE;
1517 ScValueIterator aValIter( mrContext, aRange );
1518 if ( aValIter.GetFirst( fVal, nErr ) )
1519 {
1520 bHaveValue = true;
1521 do
1522 {
1523 bRes ^= ( fVal != 0.0 );
1524 } while ( (nErr == FormulaError::NONE) &&
1525 aValIter.GetNext( fVal, nErr ) );
1526 }
1527 SetError( nErr );
1528 }
1529 }
1530 break;
1531 case svExternalSingleRef:
1532 case svExternalDoubleRef:
1533 case svMatrix:
1534 {
1535 bHaveValue = true;
1536 ScMatrixRef pMat = GetMatrix();
1537 if ( pMat )
1538 {
1539 bHaveValue = true;
1540 double fVal = pMat->Xor();
1541 FormulaError nErr = GetDoubleErrorValue( fVal );
1542 if ( nErr != FormulaError::NONE )
1543 {
1544 SetError( nErr );
1545 bRes = false;
1546 }
1547 else
1548 bRes ^= ( fVal != 0.0 );
1549 }
1550 // else: GetMatrix did set FormulaError::IllegalParameter
1551 }
1552 break;
1553 default:
1554 PopError();
1555 SetError( FormulaError::IllegalParameter);
1556 }
1557 }
1558 else
1559 Pop();
1560 }
1561 if ( bHaveValue )
1562 PushInt( int(bRes) );
1563 else
1564 PushNoValue();
1565 }
1566
1567 void ScInterpreter::ScNeg()
1568 {
1569 // Simple negation doesn't change current format type to number, keep
1570 // current type.
1571 nFuncFmtType = nCurFmtType;
1572 switch ( GetStackType() )
1573 {
1574 case svMatrix :
1575 {
1576 ScMatrixRef pMat = GetMatrix();
1577 if ( !pMat )
1578 PushIllegalParameter();
1579 else
1580 {
1581 SCSIZE nC, nR;
1582 pMat->GetDimensions( nC, nR );
1583 ScMatrixRef pResMat = GetNewMat( nC, nR, /*bEmpty*/true );
1584 if ( !pResMat )
1585 PushIllegalArgument();
1586 else
1587 {
1588 pMat->NegOp( *pResMat);
1589 PushMatrix( pResMat );
1590 }
1591 }
1592 }
1593 break;
1594 default:
1595 PushDouble( -GetDouble() );
1596 }
1597 }
1598
1599 void ScInterpreter::ScPercentSign()
1600 {
1601 nFuncFmtType = SvNumFormatType::PERCENT;
1602 const FormulaToken* pSaveCur = pCur;
1603 sal_uInt8 nSavePar = cPar;
1604 PushInt( 100 );
1605 cPar = 2;
1606 FormulaByteToken aDivOp( ocDiv, cPar );
1607 pCur = &aDivOp;
1608 ScDiv();
1609 pCur = pSaveCur;
1610 cPar = nSavePar;
1611 }
1612
1613 void ScInterpreter::ScNot()
1614 {
1615 nFuncFmtType = SvNumFormatType::LOGICAL;
1616 switch ( GetStackType() )
1617 {
1618 case svMatrix :
1619 {
1620 ScMatrixRef pMat = GetMatrix();
1621 if ( !pMat )
1622 PushIllegalParameter();
1623 else
1624 {
1625 SCSIZE nC, nR;
1626 pMat->GetDimensions( nC, nR );
1627 ScMatrixRef pResMat = GetNewMat( nC, nR, /*bEmpty*/true);
1628 if ( !pResMat )
1629 PushIllegalArgument();
1630 else
1631 {
1632 pMat->NotOp( *pResMat);
1633 PushMatrix( pResMat );
1634 }
1635 }
1636 }
1637 break;
1638 default:
1639 PushInt( int(GetDouble() == 0.0) );
1640 }
1641 }
1642
1643 void ScInterpreter::ScBitAnd()
1644 {
1645
1646 if ( !MustHaveParamCount( GetByte(), 2 ) )
1647 return;
1648
1649 double num1 = ::rtl::math::approxFloor( GetDouble());
1650 double num2 = ::rtl::math::approxFloor( GetDouble());
1651 if ( (num1 >= n2power48) || (num1 < 0) ||
1652 (num2 >= n2power48) || (num2 < 0))
1653 PushIllegalArgument();
1654 else
1655 PushDouble (static_cast<sal_uInt64>(num1) & static_cast<sal_uInt64>(num2));
1656 }
1657
1658 void ScInterpreter::ScBitOr()
1659 {
1660
1661 if ( !MustHaveParamCount( GetByte(), 2 ) )
1662 return;
1663
1664 double num1 = ::rtl::math::approxFloor( GetDouble());
1665 double num2 = ::rtl::math::approxFloor( GetDouble());
1666 if ( (num1 >= n2power48) || (num1 < 0) ||
1667 (num2 >= n2power48) || (num2 < 0))
1668 PushIllegalArgument();
1669 else
1670 PushDouble (static_cast<sal_uInt64>(num1) | static_cast<sal_uInt64>(num2));
1671 }
1672
1673 void ScInterpreter::ScBitXor()
1674 {
1675
1676 if ( !MustHaveParamCount( GetByte(), 2 ) )
1677 return;
1678
1679 double num1 = ::rtl::math::approxFloor( GetDouble());
1680 double num2 = ::rtl::math::approxFloor( GetDouble());
1681 if ( (num1 >= n2power48) || (num1 < 0) ||
1682 (num2 >= n2power48) || (num2 < 0))
1683 PushIllegalArgument();
1684 else
1685 PushDouble (static_cast<sal_uInt64>(num1) ^ static_cast<sal_uInt64>(num2));
1686 }
1687
1688 void ScInterpreter::ScBitLshift()
1689 {
1690
1691 if ( !MustHaveParamCount( GetByte(), 2 ) )
1692 return;
1693
1694 double fShift = ::rtl::math::approxFloor( GetDouble());
1695 double num = ::rtl::math::approxFloor( GetDouble());
1696 if ((num >= n2power48) || (num < 0))
1697 PushIllegalArgument();
1698 else
1699 {
1700 double fRes;
1701 if (fShift < 0)
1702 fRes = ::rtl::math::approxFloor( num / pow( 2.0, -fShift));
1703 else if (fShift == 0)
1704 fRes = num;
1705 else
1706 fRes = num * pow( 2.0, fShift);
1707 PushDouble( fRes);
1708 }
1709 }
1710
1711 void ScInterpreter::ScBitRshift()
1712 {
1713
1714 if ( !MustHaveParamCount( GetByte(), 2 ) )
1715 return;
1716
1717 double fShift = ::rtl::math::approxFloor( GetDouble());
1718 double num = ::rtl::math::approxFloor( GetDouble());
1719 if ((num >= n2power48) || (num < 0))
1720 PushIllegalArgument();
1721 else
1722 {
1723 double fRes;
1724 if (fShift < 0)
1725 fRes = num * pow( 2.0, -fShift);
1726 else if (fShift == 0)
1727 fRes = num;
1728 else
1729 fRes = ::rtl::math::approxFloor( num / pow( 2.0, fShift));
1730 PushDouble( fRes);
1731 }
1732 }
1733
1734 void ScInterpreter::ScPi()
1735 {
1736 PushDouble(M_PI);
1737 }
1738
1739 void ScInterpreter::ScRandomImpl( const std::function<double( double fFirst, double fLast )>& RandomFunc,
1740 double fFirst, double fLast )
1741 {
1742 if (bMatrixFormula)
1743 {
1744 SCCOL nCols = 0;
1745 SCROW nRows = 0;
1746 // In JumpMatrix context use its dimensions for the return matrix; the
1747 // formula cell range selected may differ, for example if the result is
1748 // to be transposed.
1749 if (GetStackType(1) == svJumpMatrix)
1750 {
1751 SCSIZE nC, nR;
1752 pStack[sp-1]->GetJumpMatrix()->GetDimensions( nC, nR);
1753 nCols = std::max<SCCOL>(0, static_cast<SCCOL>(nC));
1754 nRows = std::max<SCROW>(0, static_cast<SCROW>(nR));
1755 }
1756 else if (pMyFormulaCell)
1757 pMyFormulaCell->GetMatColsRows( nCols, nRows);
1758
1759 if (nCols == 1 && nRows == 1)
1760 {
1761 // For compatibility with existing
1762 // com.sun.star.sheet.FunctionAccess.callFunction() calls that per
1763 // default are executed in array context unless
1764 // FA.setPropertyValue("IsArrayFunction",False) was set, return a
1765 // scalar double instead of a 1x1 matrix object. tdf#128218
1766 PushDouble( RandomFunc( fFirst, fLast));
1767 return;
1768 }
1769
1770 // ScViewFunc::EnterMatrix() might be asking for
1771 // ScFormulaCell::GetResultDimensions(), which here are none so create
1772 // a 1x1 matrix at least which exactly is the case when EnterMatrix()
1773 // asks for a not selected range.
1774 if (nCols == 0)
1775 nCols = 1;
1776 if (nRows == 0)
1777 nRows = 1;
1778 ScMatrixRef pResMat = GetNewMat( static_cast<SCSIZE>(nCols), static_cast<SCSIZE>(nRows), /*bEmpty*/true );
1779 if (!pResMat)
1780 PushError( FormulaError::MatrixSize);
1781 else
1782 {
1783 for (SCCOL i=0; i < nCols; ++i)
1784 {
1785 for (SCROW j=0; j < nRows; ++j)
1786 {
1787 pResMat->PutDouble( RandomFunc( fFirst, fLast),
1788 static_cast<SCSIZE>(i), static_cast<SCSIZE>(j));
1789 }
1790 }
1791 PushMatrix( pResMat);
1792 }
1793 }
1794 else
1795 {
1796 PushDouble( RandomFunc( fFirst, fLast));
1797 }
1798 }
1799
1800 void ScInterpreter::ScRandom()
1801 {
1802 auto RandomFunc = [this]( double, double )
1803 {
1804 std::uniform_real_distribution<double> dist(0.0, 1.0);
1805 return dist(mrContext.aRNG);
1806 };
1807 ScRandomImpl( RandomFunc, 0.0, 0.0 );
1808 }
1809
1810 void ScInterpreter::ScRandArray()
1811 {
1812 sal_uInt8 nParamCount = GetByte();
1813 // optional 5th para:
1814 // TRUE for a whole number
1815 // FALSE for a decimal number - default.
1816 bool bWholeNumber = false;
1817 if (nParamCount == 5)
1818 bWholeNumber = GetBoolWithDefault(false);
1819
1820 // optional 4th para: The maximum value of the random numbers
1821 double fMax = 1.0;
1822 if (nParamCount >= 4)
1823 fMax = GetDoubleWithDefault(1.0);
1824
1825 // optional 3rd para: The minimum value of the random numbers
1826 double fMin = 0.0;
1827 if (nParamCount >= 3)
1828 fMin = GetDoubleWithDefault(0.0);
1829
1830 // optional 2nd para: The number of columns of the return array
1831 SCCOL nCols = 1;
1832 if (nParamCount >= 2)
1833 nCols = static_cast<SCCOL>(GetInt32WithDefault(1));
1834
1835 // optional 1st para: The number of rows of the return array
1836 SCROW nRows = 1;
1837 if (nParamCount >= 1)
1838 nRows = static_cast<SCROW>(GetInt32WithDefault(1));
1839
1840 if (bWholeNumber)
1841 {
1842 fMax = rtl::math::round(fMax, 0, rtl_math_RoundingMode_Up);
1843 fMin = rtl::math::round(fMin, 0, rtl_math_RoundingMode_Up);
1844 }
1845
1846 if (nGlobalError != FormulaError::NONE || fMin > fMax || nCols <= 0 || nRows <= 0)
1847 {
1848 PushIllegalArgument();
1849 return;
1850 }
1851
1852 if (bWholeNumber)
1853 fMax = std::nextafter(fMax + 1, -DBL_MAX);
1854 else
1855 fMax = std::nextafter(fMax, DBL_MAX);
1856
1857 auto RandomFunc = [this](double fFirst, double fLast, bool bWholeNum)
1858 {
1859 std::uniform_real_distribution<double> dist(fFirst, fLast);
1860 if (bWholeNum)
1861 return floor(dist(mrContext.aRNG));
1862 else
1863 return dist(mrContext.aRNG);
1864 };
1865
1866 if (nCols == 1 && nRows == 1)
1867 {
1868 PushDouble(RandomFunc(fMin, fMax, bWholeNumber));
1869 return;
1870 }
1871
1872 ScMatrixRef pResMat = GetNewMat(static_cast<SCSIZE>(nCols), static_cast<SCSIZE>(nRows), /*bEmpty*/true);
1873 if (!pResMat)
1874 PushError(FormulaError::MatrixSize);
1875 else
1876 {
1877 for (SCCOL i = 0; i < nCols; ++i)
1878 {
1879 for (SCROW j = 0; j < nRows; ++j)
1880 {
1881 pResMat->PutDouble(RandomFunc(fMin, fMax, bWholeNumber),
1882 static_cast<SCSIZE>(i), static_cast<SCSIZE>(j));
1883 }
1884 }
1885 PushMatrix(pResMat);
1886 }
1887 }
1888
1889 void ScInterpreter::ScRandbetween()
1890 {
1891 if (!MustHaveParamCount( GetByte(), 2))
1892 return;
1893
1894 // Same like scaddins/source/analysis/analysis.cxx
1895 // AnalysisAddIn::getRandbetween()
1896 double fMax = rtl::math::round( GetDouble(), 0, rtl_math_RoundingMode_Up);
1897 double fMin = rtl::math::round( GetDouble(), 0, rtl_math_RoundingMode_Up);
1898 if (nGlobalError != FormulaError::NONE || fMin > fMax)
1899 {
1900 PushIllegalArgument();
1901 return;
1902 }
1903 fMax = std::nextafter( fMax+1, -DBL_MAX);
1904 auto RandomFunc = [this]( double fFirst, double fLast )
1905 {
1906 std::uniform_real_distribution<double> dist(fFirst, fLast);
1907 return floor(dist(mrContext.aRNG));
1908 };
1909 ScRandomImpl( RandomFunc, fMin, fMax);
1910 }
1911
1912 void ScInterpreter::ScTrue()
1913 {
1914 nFuncFmtType = SvNumFormatType::LOGICAL;
1915 PushInt(1);
1916 }
1917
1918 void ScInterpreter::ScFalse()
1919 {
1920 nFuncFmtType = SvNumFormatType::LOGICAL;
1921 PushInt(0);
1922 }
1923
1924 void ScInterpreter::ScDeg()
1925 {
1926 PushDouble(basegfx::rad2deg(GetDouble()));
1927 }
1928
1929 void ScInterpreter::ScRad()
1930 {
1931 PushDouble(basegfx::deg2rad(GetDouble()));
1932 }
1933
1934 void ScInterpreter::ScSin()
1935 {
1936 PushDouble(::rtl::math::sin(GetDouble()));
1937 }
1938
1939 void ScInterpreter::ScCos()
1940 {
1941 PushDouble(::rtl::math::cos(GetDouble()));
1942 }
1943
1944 void ScInterpreter::ScTan()
1945 {
1946 PushDouble(::rtl::math::tan(GetDouble()));
1947 }
1948
1949 void ScInterpreter::ScCot()
1950 {
1951 PushDouble(1.0 / ::rtl::math::tan(GetDouble()));
1952 }
1953
1954 void ScInterpreter::ScArcSin()
1955 {
1956 PushDouble(asin(GetDouble()));
1957 }
1958
1959 void ScInterpreter::ScArcCos()
1960 {
1961 PushDouble(acos(GetDouble()));
1962 }
1963
1964 void ScInterpreter::ScArcTan()
1965 {
1966 PushDouble(atan(GetDouble()));
1967 }
1968
1969 void ScInterpreter::ScArcCot()
1970 {
1971 PushDouble((M_PI_2) - atan(GetDouble()));
1972 }
1973
1974 void ScInterpreter::ScSinHyp()
1975 {
1976 PushDouble(sinh(GetDouble()));
1977 }
1978
1979 void ScInterpreter::ScCosHyp()
1980 {
1981 PushDouble(cosh(GetDouble()));
1982 }
1983
1984 void ScInterpreter::ScTanHyp()
1985 {
1986 PushDouble(tanh(GetDouble()));
1987 }
1988
1989 void ScInterpreter::ScCotHyp()
1990 {
1991 PushDouble(1.0 / tanh(GetDouble()));
1992 }
1993
1994 void ScInterpreter::ScArcSinHyp()
1995 {
1996 PushDouble( ::rtl::math::asinh( GetDouble()));
1997 }
1998
1999 void ScInterpreter::ScArcCosHyp()
2000 {
2001 double fVal = GetDouble();
2002 if (fVal < 1.0)
2003 PushIllegalArgument();
2004 else
2005 PushDouble( ::rtl::math::acosh( fVal));
2006 }
2007
2008 void ScInterpreter::ScArcTanHyp()
2009 {
2010 double fVal = GetDouble();
2011 if (fabs(fVal) >= 1.0)
2012 PushIllegalArgument();
2013 else
2014 PushDouble(::atanh(fVal));
2015 }
2016
2017 void ScInterpreter::ScArcCotHyp()
2018 {
2019 double nVal = GetDouble();
2020 if (fabs(nVal) <= 1.0)
2021 PushIllegalArgument();
2022 else
2023 PushDouble(0.5 * log((nVal + 1.0) / (nVal - 1.0)));
2024 }
2025
2026 void ScInterpreter::ScCosecant()
2027 {
2028 PushDouble(1.0 / ::rtl::math::sin(GetDouble()));
2029 }
2030
2031 void ScInterpreter::ScSecant()
2032 {
2033 PushDouble(1.0 / ::rtl::math::cos(GetDouble()));
2034 }
2035
2036 void ScInterpreter::ScCosecantHyp()
2037 {
2038 PushDouble(1.0 / sinh(GetDouble()));
2039 }
2040
2041 void ScInterpreter::ScSecantHyp()
2042 {
2043 PushDouble(1.0 / cosh(GetDouble()));
2044 }
2045
2046 void ScInterpreter::ScExp()
2047 {
2048 PushDouble(exp(GetDouble()));
2049 }
2050
2051 void ScInterpreter::ScSqrt()
2052 {
2053 double fVal = GetDouble();
2054 if (fVal >= 0.0)
2055 PushDouble(sqrt(fVal));
2056 else
2057 PushIllegalArgument();
2058 }
2059
2060 void ScInterpreter::ScIsEmpty()
2061 {
2062 short nRes = 0;
2063 nFuncFmtType = SvNumFormatType::LOGICAL;
2064 switch ( GetRawStackType() )
2065 {
2066 case svEmptyCell:
2067 {
2068 FormulaConstTokenRef p = PopToken();
2069 if (!static_cast<const ScEmptyCellToken*>(p.get())->IsInherited())
2070 nRes = 1;
2071 }
2072 break;
2073 case svDoubleRef :
2074 case svSingleRef :
2075 {
2076 ScAddress aAdr;
2077 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2078 break;
2079 // NOTE: this differs from COUNTBLANK() ScCountEmptyCells() that
2080 // may treat ="" in the referenced cell as blank for Excel
2081 // interoperability.
2082 ScRefCellValue aCell(mrDoc, aAdr);
2083 if (aCell.getType() == CELLTYPE_NONE)
2084 nRes = 1;
2085 }
2086 break;
2087 case svExternalSingleRef:
2088 case svExternalDoubleRef:
2089 case svMatrix:
2090 {
2091 ScMatrixRef pMat = GetMatrix();
2092 if ( !pMat )
2093 ; // nothing
2094 else if ( !pJumpMatrix )
2095 nRes = pMat->IsEmptyCell( 0, 0) ? 1 : 0;
2096 else
2097 {
2098 SCSIZE nCols, nRows, nC, nR;
2099 pMat->GetDimensions( nCols, nRows);
2100 pJumpMatrix->GetPos( nC, nR);
2101 if ( nC < nCols && nR < nRows )
2102 nRes = pMat->IsEmptyCell( nC, nR) ? 1 : 0;
2103 // else: false, not empty (which is what Xcl does)
2104 }
2105 }
2106 break;
2107 default:
2108 Pop();
2109 }
2110 nGlobalError = FormulaError::NONE;
2111 PushInt( nRes );
2112 }
2113
2114 bool ScInterpreter::IsString()
2115 {
2116 nFuncFmtType = SvNumFormatType::LOGICAL;
2117 bool bRes = false;
2118 switch ( GetRawStackType() )
2119 {
2120 case svString:
2121 Pop();
2122 bRes = true;
2123 break;
2124 case svDoubleRef :
2125 case svSingleRef :
2126 {
2127 ScAddress aAdr;
2128 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2129 break;
2130
2131 ScRefCellValue aCell(mrDoc, aAdr);
2132 if (GetCellErrCode(aCell) == FormulaError::NONE)
2133 {
2134 switch (aCell.getType())
2135 {
2136 case CELLTYPE_STRING :
2137 case CELLTYPE_EDIT :
2138 bRes = true;
2139 break;
2140 case CELLTYPE_FORMULA :
2141 bRes = (!aCell.getFormula()->IsValue() && !aCell.getFormula()->IsEmpty());
2142 break;
2143 default:
2144 ; // nothing
2145 }
2146 }
2147 }
2148 break;
2149 case svExternalSingleRef:
2150 {
2151 ScExternalRefCache::TokenRef pToken;
2152 PopExternalSingleRef(pToken);
2153 if (nGlobalError == FormulaError::NONE && pToken->GetType() == svString)
2154 bRes = true;
2155 }
2156 break;
2157 case svExternalDoubleRef:
2158 case svMatrix:
2159 {
2160 ScMatrixRef pMat = GetMatrix();
2161 if ( !pMat )
2162 ; // nothing
2163 else if ( !pJumpMatrix )
2164 bRes = pMat->IsStringOrEmpty(0, 0) && !pMat->IsEmpty(0, 0);
2165 else
2166 {
2167 SCSIZE nCols, nRows, nC, nR;
2168 pMat->GetDimensions( nCols, nRows);
2169 pJumpMatrix->GetPos( nC, nR);
2170 if ( nC < nCols && nR < nRows )
2171 bRes = pMat->IsStringOrEmpty( nC, nR) && !pMat->IsEmpty( nC, nR);
2172 }
2173 }
2174 break;
2175 default:
2176 Pop();
2177 }
2178 nGlobalError = FormulaError::NONE;
2179 return bRes;
2180 }
2181
2182 void ScInterpreter::ScIsString()
2183 {
2184 PushInt( int(IsString()) );
2185 }
2186
2187 void ScInterpreter::ScIsNonString()
2188 {
2189 PushInt( int(!IsString()) );
2190 }
2191
2192 void ScInterpreter::ScIsLogical()
2193 {
2194 bool bRes = false;
2195 switch ( GetStackType() )
2196 {
2197 case svDoubleRef :
2198 case svSingleRef :
2199 {
2200 ScAddress aAdr;
2201 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2202 break;
2203
2204 ScRefCellValue aCell(mrDoc, aAdr);
2205 if (GetCellErrCode(aCell) == FormulaError::NONE)
2206 {
2207 if (aCell.hasNumeric())
2208 {
2209 sal_uInt32 nFormat = GetCellNumberFormat(aAdr, aCell);
2210 bRes = (mrContext.NFGetType(nFormat) == SvNumFormatType::LOGICAL);
2211 }
2212 }
2213 }
2214 break;
2215 case svMatrix:
2216 {
2217 double fVal;
2218 svl::SharedString aStr;
2219 ScMatValType nMatValType = GetDoubleOrStringFromMatrix( fVal, aStr);
2220 bRes = (nMatValType == ScMatValType::Boolean);
2221 }
2222 break;
2223 default:
2224 PopError();
2225 if ( nGlobalError == FormulaError::NONE )
2226 bRes = ( nCurFmtType == SvNumFormatType::LOGICAL );
2227 }
2228 nCurFmtType = nFuncFmtType = SvNumFormatType::LOGICAL;
2229 nGlobalError = FormulaError::NONE;
2230 PushInt( int(bRes) );
2231 }
2232
2233 void ScInterpreter::ScType()
2234 {
2235 short nType = 0;
2236 switch ( GetStackType() )
2237 {
2238 case svDoubleRef :
2239 case svSingleRef :
2240 {
2241 ScAddress aAdr;
2242 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2243 break;
2244
2245 ScRefCellValue aCell(mrDoc, aAdr);
2246 if (GetCellErrCode(aCell) == FormulaError::NONE)
2247 {
2248 switch (aCell.getType())
2249 {
2250 // NOTE: this is Xcl nonsense!
2251 case CELLTYPE_STRING :
2252 case CELLTYPE_EDIT :
2253 nType = 2;
2254 break;
2255 case CELLTYPE_VALUE :
2256 {
2257 sal_uInt32 nFormat = GetCellNumberFormat(aAdr, aCell);
2258 if (mrContext.NFGetType(nFormat) == SvNumFormatType::LOGICAL)
2259 nType = 4;
2260 else
2261 nType = 1;
2262 }
2263 break;
2264 case CELLTYPE_NONE:
2265 // always 1, s. tdf#73078
2266 nType = 1;
2267 break;
2268 case CELLTYPE_FORMULA :
2269 nType = 8;
2270 break;
2271 default:
2272 PushIllegalArgument();
2273 }
2274 }
2275 else
2276 nType = 16;
2277 }
2278 break;
2279 case svString:
2280 PopError();
2281 if ( nGlobalError != FormulaError::NONE )
2282 {
2283 nType = 16;
2284 nGlobalError = FormulaError::NONE;
2285 }
2286 else
2287 nType = 2;
2288 break;
2289 case svMatrix:
2290 PopMatrix();
2291 if ( nGlobalError != FormulaError::NONE )
2292 {
2293 nType = 16;
2294 nGlobalError = FormulaError::NONE;
2295 }
2296 else
2297 nType = 64;
2298 // we could return the type of one element if in JumpMatrix or
2299 // ForceArray mode, but Xcl doesn't ...
2300 break;
2301 default:
2302 PopError();
2303 if ( nGlobalError != FormulaError::NONE )
2304 {
2305 nType = 16;
2306 nGlobalError = FormulaError::NONE;
2307 }
2308 else
2309 nType = 1;
2310 }
2311 PushInt( nType );
2312 }
2313
2314 static bool lcl_FormatHasNegColor( const SvNumberformat* pFormat )
2315 {
2316 return pFormat && pFormat->GetColor( 1 );
2317 }
2318
2319 static bool lcl_FormatHasOpenPar( const SvNumberformat* pFormat )
2320 {
2321 return pFormat && (pFormat->GetFormatstring().indexOf('(') != -1);
2322 }
2323
2324 namespace {
2325
2326 void getFormatString(const ScInterpreterContext& rContext, sal_uLong nFormat, OUString& rFmtStr)
2327 {
2328 rFmtStr = rContext.NFGetCalcCellReturn(nFormat);
2329 }
2330
2331 }
2332
2333 void ScInterpreter::ScCell()
2334 { // ATTRIBUTE ; [REF]
2335 sal_uInt8 nParamCount = GetByte();
2336 if( !MustHaveParamCount( nParamCount, 1, 2 ) )
2337 return;
2338
2339 ScAddress aCellPos( aPos );
2340 if( nParamCount == 2 )
2341 {
2342 switch (GetStackType())
2343 {
2344 case svExternalSingleRef:
2345 case svExternalDoubleRef:
2346 {
2347 // Let's handle external reference separately...
2348 ScCellExternal();
2349 return;
2350 }
2351 case svDoubleRef:
2352 {
2353 // Exceptionally not an intersecting position but top left.
2354 // See ODF v1.3 part 4 OpenFormula 6.13.3 CELL
2355 ScRange aRange;
2356 PopDoubleRef( aRange);
2357 aCellPos = aRange.aStart;
2358 }
2359 break;
2360 case svSingleRef:
2361 PopSingleRef( aCellPos);
2362 break;
2363 default:
2364 PopError();
2365 SetError( FormulaError::NoRef);
2366 }
2367 }
2368 OUString aInfoType = GetString().getString();
2369 if (nGlobalError != FormulaError::NONE)
2370 PushIllegalParameter();
2371 else
2372 {
2373 ScRefCellValue aCell(mrDoc, aCellPos);
2374
2375 ScCellKeywordTranslator::transKeyword(aInfoType, &ScGlobal::GetLocale(), ocCell);
2376
2377 // *** ADDRESS INFO ***
2378 if( aInfoType == "COL" )
2379 { // column number (1-based)
2380 PushInt( aCellPos.Col() + 1 );
2381 }
2382 else if( aInfoType == "ROW" )
2383 { // row number (1-based)
2384 PushInt( aCellPos.Row() + 1 );
2385 }
2386 else if( aInfoType == "SHEET" )
2387 { // table number (1-based)
2388 PushInt( aCellPos.Tab() + 1 );
2389 }
2390 else if( aInfoType == "ADDRESS" )
2391 { // address formatted as [['FILENAME'#]$TABLE.]$COL$ROW
2392
2393 // Follow the configurable string reference address syntax as also
2394 // used by INDIRECT() (and ADDRESS() for the sheet separator).
2395 FormulaGrammar::AddressConvention eConv = maCalcConfig.meStringRefAddressSyntax;
2396 switch (eConv)
2397 {
2398 default:
2399 // Use the current address syntax if unspecified or says
2400 // one or the other or one we don't explicitly handle.
2401 eConv = mrDoc.GetAddressConvention();
2402 break;
2403 case FormulaGrammar::CONV_OOO:
2404 case FormulaGrammar::CONV_XL_A1:
2405 case FormulaGrammar::CONV_XL_R1C1:
2406 // Use that.
2407 break;
2408 }
2409
2410 ScRefFlags nFlags = (aCellPos.Tab() == aPos.Tab()) ? ScRefFlags::ADDR_ABS : ScRefFlags::ADDR_ABS_3D;
2411 OUString aStr(aCellPos.Format(nFlags, &mrDoc, eConv));
2412 PushString(aStr);
2413 }
2414 else if( aInfoType == "FILENAME" )
2415 {
2416 SCTAB nTab = aCellPos.Tab();
2417 OUString aFuncResult;
2418 if( nTab < mrDoc.GetTableCount() )
2419 {
2420 if( mrDoc.GetLinkMode( nTab ) == ScLinkMode::VALUE )
2421 mrDoc.GetName( nTab, aFuncResult );
2422 else
2423 {
2424 ScDocShell* pShell = mrDoc.GetDocumentShell();
2425 if( pShell && pShell->GetMedium() )
2426 {
2427 const INetURLObject& rURLObj = pShell->GetMedium()->GetURLObject();
2428 OUString aTabName;
2429 mrDoc.GetName( nTab, aTabName );
2430
2431 FormulaGrammar::AddressConvention eConv = maCalcConfig.meStringRefAddressSyntax;
2432 if (eConv == FormulaGrammar::CONV_UNSPECIFIED)
2433 eConv = mrDoc.GetAddressConvention();
2434
2435 if (eConv == FormulaGrammar::CONV_XL_A1 ||
2436 eConv == FormulaGrammar::CONV_XL_R1C1 ||
2437 eConv == FormulaGrammar::CONV_XL_OOX)
2438 {
2439 // file name and table name: FILEPATH/[FILENAME]TABLE
2440 if (!comphelper::LibreOfficeKit::isActive())
2441 aFuncResult = rURLObj.GetPartBeforeLastName();
2442 aFuncResult += "[" + rURLObj.GetLastName(INetURLObject::DecodeMechanism::Unambiguous) +
2443 "]" + aTabName;
2444 }
2445 else
2446 {
2447 // file name and table name: 'FILEPATH/FILENAME'#$TABLE
2448 aFuncResult = "'";
2449 if (!comphelper::LibreOfficeKit::isActive())
2450 aFuncResult += rURLObj.GetMainURL(INetURLObject::DecodeMechanism::Unambiguous);
2451 else
2452 aFuncResult += rURLObj.GetLastName(INetURLObject::DecodeMechanism::Unambiguous);
2453 aFuncResult += "'#$" + aTabName;
2454 }
2455 }
2456 }
2457 }
2458 PushString( aFuncResult );
2459 }
2460 else if( aInfoType == "COORD" )
2461 { // address, lotus 1-2-3 formatted: $TABLE:$COL$ROW
2462 // Yes, passing tab as col is intentional!
2463 OUString aCellStr1 =
2464 ScAddress( static_cast<SCCOL>(aCellPos.Tab()), 0, 0 ).Format(
2465 (ScRefFlags::COL_ABS|ScRefFlags::COL_VALID), nullptr, mrDoc.GetAddressConvention() );
2466 OUString aCellStr2 =
2467 aCellPos.Format((ScRefFlags::COL_ABS|ScRefFlags::COL_VALID|ScRefFlags::ROW_ABS|ScRefFlags::ROW_VALID),
2468 nullptr, mrDoc.GetAddressConvention());
2469 OUString aFuncResult = aCellStr1 + ":" + aCellStr2;
2470 PushString( aFuncResult );
2471 }
2472
2473 // *** CELL PROPERTIES ***
2474 else if( aInfoType == "CONTENTS" )
2475 { // contents of the cell, no formatting
2476 if (aCell.hasString())
2477 {
2478 svl::SharedString aStr;
2479 GetCellString(aStr, aCell);
2480 PushString( aStr );
2481 }
2482 else
2483 PushDouble(GetCellValue(aCellPos, aCell));
2484 }
2485 else if( aInfoType == "TYPE" )
2486 { // b = blank; l = string (label); v = otherwise (value)
2487 sal_Unicode c;
2488 if (aCell.hasString())
2489 c = 'l';
2490 else
2491 c = aCell.hasNumeric() ? 'v' : 'b';
2492 PushString( OUString(c) );
2493 }
2494 else if( aInfoType == "WIDTH" )
2495 { // column width (rounded off as count of zero characters in standard font and size)
2496 Printer* pPrinter = mrDoc.GetPrinter();
2497 MapMode aOldMode( pPrinter->GetMapMode() );
2498 vcl::Font aOldFont( pPrinter->GetFont() );
2499 vcl::Font aDefFont;
2500
2501 pPrinter->SetMapMode(MapMode(MapUnit::MapTwip));
2502 // font color doesn't matter here
2503 mrDoc.getCellAttributeHelper().getDefaultCellAttribute().fillFontOnly(aDefFont, pPrinter);
2504 pPrinter->SetFont(aDefFont);
2505 tools::Long nZeroWidth = pPrinter->GetTextWidth( OUString( '0' ) );
2506 assert(nZeroWidth != 0);
2507 pPrinter->SetFont( aOldFont );
2508 pPrinter->SetMapMode( aOldMode );
2509 int nZeroCount = static_cast<int>(mrDoc.GetColWidth( aCellPos.Col(), aCellPos.Tab() ) / nZeroWidth);
2510 PushInt( nZeroCount );
2511 }
2512 else if( aInfoType == "PREFIX" )
2513 { // ' = left; " = right; ^ = centered
2514 sal_Unicode c = 0;
2515 if (aCell.hasString())
2516 {
2517 const SvxHorJustifyItem* pJustAttr = mrDoc.GetAttr( aCellPos, ATTR_HOR_JUSTIFY );
2518 switch( pJustAttr->GetValue() )
2519 {
2520 case SvxCellHorJustify::Standard:
2521 case SvxCellHorJustify::Left:
2522 case SvxCellHorJustify::Block: c = '\''; break;
2523 case SvxCellHorJustify::Center: c = '^'; break;
2524 case SvxCellHorJustify::Right: c = '"'; break;
2525 case SvxCellHorJustify::Repeat: c = '\\'; break;
2526 }
2527 }
2528 PushString( OUString(c) );
2529 }
2530 else if( aInfoType == "PROTECT" )
2531 { // 1 = cell locked
2532 const ScProtectionAttr* pProtAttr = mrDoc.GetAttr( aCellPos, ATTR_PROTECTION );
2533 PushInt( pProtAttr->GetProtection() ? 1 : 0 );
2534 }
2535
2536 // *** FORMATTING ***
2537 else if( aInfoType == "FORMAT" )
2538 { // specific format code for standard formats
2539 OUString aFuncResult;
2540 sal_uInt32 nFormat = mrDoc.GetNumberFormat( aCellPos );
2541 getFormatString(mrContext, nFormat, aFuncResult);
2542 PushString( aFuncResult );
2543 }
2544 else if( aInfoType == "COLOR" )
2545 { // 1 = negative values are colored, otherwise 0
2546 const SvNumberformat* pFormat = mrContext.NFGetFormatEntry( mrDoc.GetNumberFormat( aCellPos ) );
2547 PushInt( lcl_FormatHasNegColor( pFormat ) ? 1 : 0 );
2548 }
2549 else if( aInfoType == "PARENTHESES" )
2550 { // 1 = format string contains a '(' character, otherwise 0
2551 const SvNumberformat* pFormat = mrContext.NFGetFormatEntry( mrDoc.GetNumberFormat( aCellPos ) );
2552 PushInt( lcl_FormatHasOpenPar( pFormat ) ? 1 : 0 );
2553 }
2554 else
2555 PushIllegalArgument();
2556 }
2557 }
2558
2559 void ScInterpreter::ScCellExternal()
2560 {
2561 sal_uInt16 nFileId;
2562 OUString aTabName;
2563 ScSingleRefData aRef;
2564 ScExternalRefCache::TokenRef pToken;
2565 ScExternalRefCache::CellFormat aFmt;
2566 PopExternalSingleRef(nFileId, aTabName, aRef, pToken, &aFmt);
2567 if (nGlobalError != FormulaError::NONE)
2568 {
2569 PushError( nGlobalError);
2570 return;
2571 }
2572
2573 OUString aInfoType = GetString().getString();
2574 if (nGlobalError != FormulaError::NONE)
2575 {
2576 PushError( nGlobalError);
2577 return;
2578 }
2579
2580 SCCOL nCol;
2581 SCROW nRow;
2582 SCTAB nTab;
2583 aRef.SetAbsTab(0); // external ref has a tab index of -1, which SingleRefToVars() don't like.
2584 SingleRefToVars(aRef, nCol, nRow, nTab);
2585 if (nGlobalError != FormulaError::NONE)
2586 {
2587 PushIllegalParameter();
2588 return;
2589 }
2590 aRef.SetAbsTab(-1); // revert the value.
2591
2592 ScCellKeywordTranslator::transKeyword(aInfoType, &ScGlobal::GetLocale(), ocCell);
2593 ScExternalRefManager* pRefMgr = mrDoc.GetExternalRefManager();
2594
2595 if ( aInfoType == "COL" )
2596 PushInt(nCol + 1);
2597 else if ( aInfoType == "ROW" )
2598 PushInt(nRow + 1);
2599 else if ( aInfoType == "SHEET" )
2600 {
2601 // For SHEET, No idea what number we should set, but let's always set
2602 // 1 if the external sheet exists, no matter what sheet. Excel does
2603 // the same.
2604 if (pRefMgr->getCacheTable(nFileId, aTabName, false))
2605 PushInt(1);
2606 else
2607 SetError(FormulaError::NoName);
2608 }
2609 else if ( aInfoType == "ADDRESS" )
2610 {
2611 // ODF 1.2 says we need to always display address using the ODF A1 grammar.
2612 ScTokenArray aArray(mrDoc);
2613 aArray.AddExternalSingleReference(nFileId, svl::SharedString( aTabName), aRef); // string not interned
2614 ScCompiler aComp(mrDoc, aPos, aArray, formula::FormulaGrammar::GRAM_ODFF_A1);
2615 OUString aStr;
2616 aComp.CreateStringFromTokenArray(aStr);
2617 PushString(aStr);
2618 }
2619 else if ( aInfoType == "FILENAME" )
2620 {
2621 const OUString* p = pRefMgr->getExternalFileName(nFileId);
2622 if (!p)
2623 {
2624 // In theory this should never happen...
2625 SetError(FormulaError::NoName);
2626 return;
2627 }
2628
2629 OUString aBuf;
2630 FormulaGrammar::AddressConvention eConv = maCalcConfig.meStringRefAddressSyntax;
2631 if (eConv == FormulaGrammar::CONV_UNSPECIFIED)
2632 eConv = mrDoc.GetAddressConvention();
2633
2634 if (eConv == FormulaGrammar::CONV_XL_A1 ||
2635 eConv == FormulaGrammar::CONV_XL_R1C1 ||
2636 eConv == FormulaGrammar::CONV_XL_OOX)
2637 {
2638 // 'file URI/[FileName]SheetName
2639 sal_Int32 nPos = p->lastIndexOf('/');
2640 aBuf = OUString::Concat(p->subView(0, nPos + 1))
2641 + "[" + p->subView(nPos + 1) + "]"
2642 + aTabName;
2643 }
2644 else
2645 {
2646 // 'file URI'#$SheetName
2647 aBuf = "'" + *p + "'#$" + aTabName;
2648 }
2649
2650 PushString(aBuf);
2651 }
2652 else if ( aInfoType == "CONTENTS" )
2653 {
2654 switch (pToken->GetType())
2655 {
2656 case svString:
2657 PushString(pToken->GetString());
2658 break;
2659 case svDouble:
2660 PushString(OUString::number(pToken->GetDouble()));
2661 break;
2662 case svError:
2663 PushString(ScGlobal::GetErrorString(pToken->GetError()));
2664 break;
2665 default:
2666 PushString(OUString());
2667 }
2668 }
2669 else if ( aInfoType == "TYPE" )
2670 {
2671 sal_Unicode c = 'v';
2672 switch (pToken->GetType())
2673 {
2674 case svString:
2675 c = 'l';
2676 break;
2677 case svEmptyCell:
2678 c = 'b';
2679 break;
2680 default:
2681 ;
2682 }
2683 PushString(OUString(c));
2684 }
2685 else if ( aInfoType == "FORMAT" )
2686 {
2687 OUString aFmtStr;
2688 sal_uLong nFmt = aFmt.mbIsSet ? aFmt.mnIndex : 0;
2689 getFormatString(mrContext, nFmt, aFmtStr);
2690 PushString(aFmtStr);
2691 }
2692 else if ( aInfoType == "COLOR" )
2693 {
2694 // 1 = negative values are colored, otherwise 0
2695 int nVal = 0;
2696 if (aFmt.mbIsSet)
2697 {
2698 const SvNumberformat* pFormat = mrContext.NFGetFormatEntry(aFmt.mnIndex);
2699 nVal = lcl_FormatHasNegColor(pFormat) ? 1 : 0;
2700 }
2701 PushInt(nVal);
2702 }
2703 else if ( aInfoType == "PARENTHESES" )
2704 {
2705 // 1 = format string contains a '(' character, otherwise 0
2706 int nVal = 0;
2707 if (aFmt.mbIsSet)
2708 {
2709 const SvNumberformat* pFormat = mrContext.NFGetFormatEntry(aFmt.mnIndex);
2710 nVal = lcl_FormatHasOpenPar(pFormat) ? 1 : 0;
2711 }
2712 PushInt(nVal);
2713 }
2714 else
2715 PushIllegalParameter();
2716 }
2717
2718 void ScInterpreter::ScIsRef()
2719 {
2720 nFuncFmtType = SvNumFormatType::LOGICAL;
2721 bool bRes = false;
2722 switch ( GetStackType() )
2723 {
2724 case svSingleRef :
2725 {
2726 ScAddress aAdr;
2727 PopSingleRef( aAdr );
2728 if ( nGlobalError == FormulaError::NONE )
2729 bRes = true;
2730 }
2731 break;
2732 case svDoubleRef :
2733 {
2734 ScRange aRange;
2735 PopDoubleRef( aRange );
2736 if ( nGlobalError == FormulaError::NONE )
2737 bRes = true;
2738 }
2739 break;
2740 case svRefList :
2741 {
2742 FormulaConstTokenRef x = PopToken();
2743 if ( nGlobalError == FormulaError::NONE )
2744 bRes = !x->GetRefList()->empty();
2745 }
2746 break;
2747 case svExternalSingleRef:
2748 {
2749 ScExternalRefCache::TokenRef pToken;
2750 PopExternalSingleRef(pToken);
2751 if (nGlobalError == FormulaError::NONE)
2752 bRes = true;
2753 }
2754 break;
2755 case svExternalDoubleRef:
2756 {
2757 ScExternalRefCache::TokenArrayRef pArray;
2758 PopExternalDoubleRef(pArray);
2759 if (nGlobalError == FormulaError::NONE)
2760 bRes = true;
2761 }
2762 break;
2763 default:
2764 Pop();
2765 }
2766 nGlobalError = FormulaError::NONE;
2767 PushInt( int(bRes) );
2768 }
2769
2770 void ScInterpreter::ScIsValue()
2771 {
2772 nFuncFmtType = SvNumFormatType::LOGICAL;
2773 bool bRes = false;
2774 switch ( GetRawStackType() )
2775 {
2776 case svDouble:
2777 Pop();
2778 bRes = true;
2779 break;
2780 case svDoubleRef :
2781 case svSingleRef :
2782 {
2783 ScAddress aAdr;
2784 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2785 break;
2786
2787 ScRefCellValue aCell(mrDoc, aAdr);
2788 if (GetCellErrCode(aCell) == FormulaError::NONE)
2789 {
2790 switch (aCell.getType())
2791 {
2792 case CELLTYPE_VALUE :
2793 bRes = true;
2794 break;
2795 case CELLTYPE_FORMULA :
2796 bRes = (aCell.getFormula()->IsValue() && !aCell.getFormula()->IsEmpty());
2797 break;
2798 default:
2799 ; // nothing
2800 }
2801 }
2802 }
2803 break;
2804 case svExternalSingleRef:
2805 {
2806 ScExternalRefCache::TokenRef pToken;
2807 PopExternalSingleRef(pToken);
2808 if (nGlobalError == FormulaError::NONE && pToken->GetType() == svDouble)
2809 bRes = true;
2810 }
2811 break;
2812 case svExternalDoubleRef:
2813 case svMatrix:
2814 {
2815 ScMatrixRef pMat = GetMatrix();
2816 if ( !pMat )
2817 ; // nothing
2818 else if ( !pJumpMatrix )
2819 {
2820 if (pMat->GetErrorIfNotString( 0, 0) == FormulaError::NONE)
2821 bRes = pMat->IsValue( 0, 0);
2822 }
2823 else
2824 {
2825 SCSIZE nCols, nRows, nC, nR;
2826 pMat->GetDimensions( nCols, nRows);
2827 pJumpMatrix->GetPos( nC, nR);
2828 if ( nC < nCols && nR < nRows )
2829 if (pMat->GetErrorIfNotString( nC, nR) == FormulaError::NONE)
2830 bRes = pMat->IsValue( nC, nR);
2831 }
2832 }
2833 break;
2834 default:
2835 Pop();
2836 }
2837 nGlobalError = FormulaError::NONE;
2838 PushInt( int(bRes) );
2839 }
2840
2841 void ScInterpreter::ScIsFormula()
2842 {
2843 nFuncFmtType = SvNumFormatType::LOGICAL;
2844 bool bRes = false;
2845 switch ( GetStackType() )
2846 {
2847 case svDoubleRef :
2848 if (IsInArrayContext())
2849 {
2850 SCCOL nCol1, nCol2;
2851 SCROW nRow1, nRow2;
2852 SCTAB nTab1, nTab2;
2853 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2854 if (nGlobalError != FormulaError::NONE)
2855 {
2856 PushError( nGlobalError);
2857 return;
2858 }
2859 if (nTab1 != nTab2)
2860 {
2861 PushIllegalArgument();
2862 return;
2863 }
2864
2865 ScMatrixRef pResMat = GetNewMat( static_cast<SCSIZE>(nCol2 - nCol1 + 1),
2866 static_cast<SCSIZE>(nRow2 - nRow1 + 1), true);
2867 if (!pResMat)
2868 {
2869 PushError( FormulaError::MatrixSize);
2870 return;
2871 }
2872
2873 /* TODO: we really should have a gap-aware cell iterator. */
2874 SCSIZE i=0, j=0;
2875 ScAddress aAdr( 0, 0, nTab1);
2876 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2877 {
2878 aAdr.SetCol(nCol);
2879 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
2880 {
2881 aAdr.SetRow(nRow);
2882 ScRefCellValue aCell(mrDoc, aAdr);
2883 pResMat->PutBoolean( (aCell.getType() == CELLTYPE_FORMULA), i,j);
2884 ++j;
2885 }
2886 ++i;
2887 j = 0;
2888 }
2889
2890 PushMatrix( pResMat);
2891 return;
2892 }
2893 [[fallthrough]];
2894 case svSingleRef :
2895 {
2896 ScAddress aAdr;
2897 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2898 break;
2899
2900 bRes = (mrDoc.GetCellType(aAdr) == CELLTYPE_FORMULA);
2901 }
2902 break;
2903 default:
2904 Pop();
2905 }
2906 nGlobalError = FormulaError::NONE;
2907 PushInt( int(bRes) );
2908 }
2909
2910 void ScInterpreter::ScFormula()
2911 {
2912 OUString aFormula;
2913 switch ( GetStackType() )
2914 {
2915 case svDoubleRef :
2916 if (IsInArrayContext())
2917 {
2918 SCCOL nCol1, nCol2;
2919 SCROW nRow1, nRow2;
2920 SCTAB nTab1, nTab2;
2921 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2922 if (nGlobalError != FormulaError::NONE)
2923 break;
2924
2925 if (nTab1 != nTab2)
2926 {
2927 SetError( FormulaError::IllegalArgument);
2928 break;
2929 }
2930
2931 ScMatrixRef pResMat = GetNewMat( nCol2 - nCol1 + 1, nRow2 - nRow1 + 1, true);
2932 if (!pResMat)
2933 break;
2934
2935 /* TODO: use a column iterator instead? */
2936 SCSIZE i=0, j=0;
2937 ScAddress aAdr(0,0,nTab1);
2938 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2939 {
2940 aAdr.SetCol(nCol);
2941 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
2942 {
2943 aAdr.SetRow(nRow);
2944 ScRefCellValue aCell(mrDoc, aAdr);
2945 switch (aCell.getType())
2946 {
2947 case CELLTYPE_FORMULA :
2948 aFormula = aCell.getFormula()->GetFormula(formula::FormulaGrammar::GRAM_UNSPECIFIED, &mrContext);
2949 pResMat->PutString( mrStrPool.intern( aFormula), i,j);
2950 break;
2951 default:
2952 pResMat->PutError( FormulaError::NotAvailable, i,j);
2953 }
2954 ++j;
2955 }
2956 ++i;
2957 j = 0;
2958 }
2959
2960 PushMatrix( pResMat);
2961 return;
2962 }
2963 [[fallthrough]];
2964 case svSingleRef :
2965 {
2966 ScAddress aAdr;
2967 if ( !PopDoubleRefOrSingleRef( aAdr ) )
2968 break;
2969
2970 ScRefCellValue aCell(mrDoc, aAdr);
2971 switch (aCell.getType())
2972 {
2973 case CELLTYPE_FORMULA :
2974 aFormula = aCell.getFormula()->GetFormula(formula::FormulaGrammar::GRAM_UNSPECIFIED, &mrContext);
2975 break;
2976 default:
2977 SetError( FormulaError::NotAvailable );
2978 }
2979 }
2980 break;
2981 default:
2982 PopError();
2983 SetError( FormulaError::NotAvailable );
2984 }
2985 PushString( aFormula );
2986 }
2987
2988 void ScInterpreter::ScIsNV()
2989 {
2990 nFuncFmtType = SvNumFormatType::LOGICAL;
2991 bool bRes = false;
2992 switch ( GetStackType() )
2993 {
2994 case svDoubleRef :
2995 case svSingleRef :
2996 {
2997 ScAddress aAdr;
2998 bool bOk = PopDoubleRefOrSingleRef( aAdr );
2999 if ( nGlobalError == FormulaError::NotAvailable )
3000 bRes = true;
3001 else if (bOk)
3002 {
3003 ScRefCellValue aCell(mrDoc, aAdr);
3004 FormulaError nErr = GetCellErrCode(aCell);
3005 bRes = (nErr == FormulaError::NotAvailable);
3006 }
3007 }
3008 break;
3009 case svExternalSingleRef:
3010 {
3011 ScExternalRefCache::TokenRef pToken;
3012 PopExternalSingleRef(pToken);
3013 if (nGlobalError == FormulaError::NotAvailable ||
3014 (pToken && pToken->GetType() == svError && pToken->GetError() == FormulaError::NotAvailable))
3015 bRes = true;
3016 }
3017 break;
3018 case svExternalDoubleRef:
3019 case svMatrix:
3020 {
3021 ScMatrixRef pMat = GetMatrix();
3022 if ( !pMat )
3023 ; // nothing
3024 else if ( !pJumpMatrix )
3025 bRes = (pMat->GetErrorIfNotString( 0, 0) == FormulaError::NotAvailable);
3026 else
3027 {
3028 SCSIZE nCols, nRows, nC, nR;
3029 pMat->GetDimensions( nCols, nRows);
3030 pJumpMatrix->GetPos( nC, nR);
3031 if ( nC < nCols && nR < nRows )
3032 bRes = (pMat->GetErrorIfNotString( nC, nR) == FormulaError::NotAvailable);
3033 }
3034 }
3035 break;
3036 default:
3037 PopError();
3038 if ( nGlobalError == FormulaError::NotAvailable )
3039 bRes = true;
3040 }
3041 nGlobalError = FormulaError::NONE;
3042 PushInt( int(bRes) );
3043 }
3044
3045 void ScInterpreter::ScIsErr()
3046 {
3047 nFuncFmtType = SvNumFormatType::LOGICAL;
3048 bool bRes = false;
3049 switch ( GetStackType() )
3050 {
3051 case svDoubleRef :
3052 case svSingleRef :
3053 {
3054 ScAddress aAdr;
3055 bool bOk = PopDoubleRefOrSingleRef( aAdr );
3056 if ( !bOk || (nGlobalError != FormulaError::NONE && nGlobalError != FormulaError::NotAvailable) )
3057 bRes = true;
3058 else
3059 {
3060 ScRefCellValue aCell(mrDoc, aAdr);
3061 FormulaError nErr = GetCellErrCode(aCell);
3062 bRes = (nErr != FormulaError::NONE && nErr != FormulaError::NotAvailable);
3063 }
3064 }
3065 break;
3066 case svExternalSingleRef:
3067 {
3068 ScExternalRefCache::TokenRef pToken;
3069 PopExternalSingleRef(pToken);
3070 if ((nGlobalError != FormulaError::NONE && nGlobalError != FormulaError::NotAvailable) || !pToken ||
3071 (pToken->GetType() == svError && pToken->GetError() != FormulaError::NotAvailable))
3072 bRes = true;
3073 }
3074 break;
3075 case svExternalDoubleRef:
3076 case svMatrix:
3077 {
3078 ScMatrixRef pMat = GetMatrix();
3079 if ( nGlobalError != FormulaError::NONE || !pMat )
3080 bRes = ((nGlobalError != FormulaError::NONE && nGlobalError != FormulaError::NotAvailable) || !pMat);
3081 else if ( !pJumpMatrix )
3082 {
3083 FormulaError nErr = pMat->GetErrorIfNotString( 0, 0);
3084 bRes = (nErr != FormulaError::NONE && nErr != FormulaError::NotAvailable);
3085 }
3086 else
3087 {
3088 SCSIZE nCols, nRows, nC, nR;
3089 pMat->GetDimensions( nCols, nRows);
3090 pJumpMatrix->GetPos( nC, nR);
3091 if ( nC < nCols && nR < nRows )
3092 {
3093 FormulaError nErr = pMat->GetErrorIfNotString( nC, nR);
3094 bRes = (nErr != FormulaError::NONE && nErr != FormulaError::NotAvailable);
3095 }
3096 }
3097 }
3098 break;
3099 default:
3100 PopError();
3101 if ( nGlobalError != FormulaError::NONE && nGlobalError != FormulaError::NotAvailable )
3102 bRes = true;
3103 }
3104 nGlobalError = FormulaError::NONE;
3105 PushInt( int(bRes) );
3106 }
3107
3108 void ScInterpreter::ScIsError()
3109 {
3110 nFuncFmtType = SvNumFormatType::LOGICAL;
3111 bool bRes = false;
3112 switch ( GetStackType() )
3113 {
3114 case svDoubleRef :
3115 case svSingleRef :
3116 {
3117 ScAddress aAdr;
3118 if ( !PopDoubleRefOrSingleRef( aAdr ) )
3119 {
3120 bRes = true;
3121 break;
3122 }
3123 if ( nGlobalError != FormulaError::NONE )
3124 bRes = true;
3125 else
3126 {
3127 ScRefCellValue aCell(mrDoc, aAdr);
3128 bRes = (GetCellErrCode(aCell) != FormulaError::NONE);
3129 }
3130 }
3131 break;
3132 case svExternalSingleRef:
3133 {
3134 ScExternalRefCache::TokenRef pToken;
3135 PopExternalSingleRef(pToken);
3136 if (nGlobalError != FormulaError::NONE || pToken->GetType() == svError)
3137 bRes = true;
3138 }
3139 break;
3140 case svExternalDoubleRef:
3141 case svMatrix:
3142 {
3143 ScMatrixRef pMat = GetMatrix();
3144 if ( nGlobalError != FormulaError::NONE || !pMat )
3145 bRes = true;
3146 else if ( !pJumpMatrix )
3147 bRes = (pMat->GetErrorIfNotString( 0, 0) != FormulaError::NONE);
3148 else
3149 {
3150 SCSIZE nCols, nRows, nC, nR;
3151 pMat->GetDimensions( nCols, nRows);
3152 pJumpMatrix->GetPos( nC, nR);
3153 if ( nC < nCols && nR < nRows )
3154 bRes = (pMat->GetErrorIfNotString( nC, nR) != FormulaError::NONE);
3155 }
3156 }
3157 break;
3158 default:
3159 PopError();
3160 if ( nGlobalError != FormulaError::NONE )
3161 bRes = true;
3162 }
3163 nGlobalError = FormulaError::NONE;
3164 PushInt( int(bRes) );
3165 }
3166
3167 bool ScInterpreter::IsEven()
3168 {
3169 nFuncFmtType = SvNumFormatType::LOGICAL;
3170 bool bRes = false;
3171 double fVal = 0.0;
3172 switch ( GetStackType() )
3173 {
3174 case svDoubleRef :
3175 case svSingleRef :
3176 {
3177 ScAddress aAdr;
3178 if ( !PopDoubleRefOrSingleRef( aAdr ) )
3179 break;
3180
3181 ScRefCellValue aCell(mrDoc, aAdr);
3182 FormulaError nErr = GetCellErrCode(aCell);
3183 if (nErr != FormulaError::NONE)
3184 SetError(nErr);
3185 else
3186 {
3187 switch (aCell.getType())
3188 {
3189 case CELLTYPE_VALUE :
3190 fVal = GetCellValue(aAdr, aCell);
3191 bRes = true;
3192 break;
3193 case CELLTYPE_FORMULA :
3194 if (aCell.getFormula()->IsValue())
3195 {
3196 fVal = GetCellValue(aAdr, aCell);
3197 bRes = true;
3198 }
3199 break;
3200 default:
3201 ; // nothing
3202 }
3203 }
3204 }
3205 break;
3206 case svDouble:
3207 {
3208 fVal = PopDouble();
3209 bRes = true;
3210 }
3211 break;
3212 case svExternalSingleRef:
3213 {
3214 ScExternalRefCache::TokenRef pToken;
3215 PopExternalSingleRef(pToken);
3216 if (nGlobalError == FormulaError::NONE && pToken->GetType() == svDouble)
3217 {
3218 fVal = pToken->GetDouble();
3219 bRes = true;
3220 }
3221 }
3222 break;
3223 case svExternalDoubleRef:
3224 case svMatrix:
3225 {
3226 ScMatrixRef pMat = GetMatrix();
3227 if ( !pMat )
3228 ; // nothing
3229 else if ( !pJumpMatrix )
3230 {
3231 bRes = pMat->IsValue( 0, 0);
3232 if ( bRes )
3233 fVal = pMat->GetDouble( 0, 0);
3234 }
3235 else
3236 {
3237 SCSIZE nCols, nRows, nC, nR;
3238 pMat->GetDimensions( nCols, nRows);
3239 pJumpMatrix->GetPos( nC, nR);
3240 if ( nC < nCols && nR < nRows )
3241 {
3242 bRes = pMat->IsValue( nC, nR);
3243 if ( bRes )
3244 fVal = pMat->GetDouble( nC, nR);
3245 }
3246 else
3247 SetError( FormulaError::NoValue);
3248 }
3249 }
3250 break;
3251 default:
3252 ; // nothing
3253 }
3254 if ( !bRes )
3255 SetError( FormulaError::IllegalParameter);
3256 else
3257 bRes = ( fmod( ::rtl::math::approxFloor( fabs( fVal ) ), 2.0 ) < 0.5 );
3258 return bRes;
3259 }
3260
3261 void ScInterpreter::ScIsEven()
3262 {
3263 PushInt( int(IsEven()) );
3264 }
3265
3266 void ScInterpreter::ScIsOdd()
3267 {
3268 PushInt( int(!IsEven()) );
3269 }
3270
3271 void ScInterpreter::ScN()
3272 {
3273 FormulaError nErr = nGlobalError;
3274 nGlobalError = FormulaError::NONE;
3275 // Temporarily override the ConvertStringToValue() error for
3276 // GetCellValue() / GetCellValueOrZero()
3277 FormulaError nSErr = mnStringNoValueError;
3278 mnStringNoValueError = FormulaError::CellNoValue;
3279 double fVal = GetDouble();
3280 mnStringNoValueError = nSErr;
3281 if (nErr != FormulaError::NONE)
3282 nGlobalError = nErr; // preserve previous error if any
3283 else if (nGlobalError == FormulaError::CellNoValue)
3284 nGlobalError = FormulaError::NONE; // reset temporary detection error
3285 PushDouble(fVal);
3286 }
3287
3288 void ScInterpreter::ScTrim()
3289 {
3290 // Doesn't only trim but also removes duplicated blanks within!
3291 OUString aVal = comphelper::string::strip(GetString().getString(), ' ');
3292 OUStringBuffer aStr;
3293 const sal_Unicode* p = aVal.getStr();
3294 const sal_Unicode* const pEnd = p + aVal.getLength();
3295 while ( p < pEnd )
3296 {
3297 if ( *p != ' ' || p[-1] != ' ' ) // first can't be ' ', so -1 is fine
3298 aStr.append(*p);
3299 p++;
3300 }
3301 PushString(aStr.makeStringAndClear());
3302 }
3303
3304 void ScInterpreter::ScUpper()
3305 {
3306 OUString aString = ScGlobal::getCharClass().uppercase(GetString().getString());
3307 PushString(aString);
3308 }
3309
3310 void ScInterpreter::ScProper()
3311 {
3312 //2do: what to do with I18N-CJK ?!?
3313 OUStringBuffer aStr(GetString().getString());
3314 const sal_Int32 nLen = aStr.getLength();
3315 if ( nLen > 0 )
3316 {
3317 OUString aUpr(ScGlobal::getCharClass().uppercase(aStr.toString()));
3318 OUString aLwr(ScGlobal::getCharClass().lowercase(aStr.toString()));
3319 aStr[0] = aUpr[0];
3320 sal_Int32 nPos = 1;
3321 while( nPos < nLen )
3322 {
3323 OUString aTmpStr( aStr[nPos-1] );
3324 if ( !ScGlobal::getCharClass().isLetter( aTmpStr, 0 ) )
3325 aStr[nPos] = aUpr[nPos];
3326 else
3327 aStr[nPos] = aLwr[nPos];
3328 ++nPos;
3329 }
3330 }
3331 PushString(aStr.makeStringAndClear());
3332 }
3333
3334 void ScInterpreter::ScLower()
3335 {
3336 OUString aString = ScGlobal::getCharClass().lowercase(GetString().getString());
3337 PushString(aString);
3338 }
3339
3340 void ScInterpreter::ScLen()
3341 {
3342 OUString aStr = GetString().getString();
3343 sal_Int32 nIdx = 0;
3344 sal_Int32 nCnt = 0;
3345 while ( nIdx < aStr.getLength() )
3346 {
3347 aStr.iterateCodePoints( &nIdx );
3348 ++nCnt;
3349 }
3350 PushDouble( nCnt );
3351 }
3352
3353 void ScInterpreter::ScT()
3354 {
3355 switch ( GetStackType() )
3356 {
3357 case svDoubleRef :
3358 case svSingleRef :
3359 {
3360 ScAddress aAdr;
3361 if ( !PopDoubleRefOrSingleRef( aAdr ) )
3362 {
3363 PushInt(0);
3364 return ;
3365 }
3366 bool bValue = false;
3367 ScRefCellValue aCell(mrDoc, aAdr);
3368 if (GetCellErrCode(aCell) == FormulaError::NONE)
3369 {
3370 switch (aCell.getType())
3371 {
3372 case CELLTYPE_VALUE :
3373 bValue = true;
3374 break;
3375 case CELLTYPE_FORMULA :
3376 bValue = aCell.getFormula()->IsValue();
3377 break;
3378 default:
3379 ; // nothing
3380 }
3381 }
3382 if ( bValue )
3383 PushString(OUString());
3384 else
3385 {
3386 // like GetString()
3387 svl::SharedString aStr;
3388 GetCellString(aStr, aCell);
3389 PushString(aStr);
3390 }
3391 }
3392 break;
3393 case svMatrix:
3394 case svExternalSingleRef:
3395 case svExternalDoubleRef:
3396 {
3397 double fVal;
3398 svl::SharedString aStr;
3399 ScMatValType nMatValType = GetDoubleOrStringFromMatrix( fVal, aStr);
3400 if (ScMatrix::IsValueType( nMatValType))
3401 PushString(svl::SharedString::getEmptyString());
3402 else
3403 PushString( aStr);
3404 }
3405 break;
3406 case svDouble :
3407 {
3408 PopError();
3409 PushString( OUString() );
3410 }
3411 break;
3412 case svString :
3413 ; // leave on stack
3414 break;
3415 default :
3416 PushError( FormulaError::UnknownOpCode);
3417 }
3418 }
3419
3420 void ScInterpreter::ScValue()
3421 {
3422 OUString aInputString;
3423 double fVal;
3424
3425 switch ( GetRawStackType() )
3426 {
3427 case svMissing:
3428 case svEmptyCell:
3429 Pop();
3430 PushInt(0);
3431 return;
3432 case svDouble:
3433 return; // leave on stack
3434
3435 case svSingleRef:
3436 case svDoubleRef:
3437 {
3438 ScAddress aAdr;
3439 if ( !PopDoubleRefOrSingleRef( aAdr ) )
3440 {
3441 PushInt(0);
3442 return;
3443 }
3444 ScRefCellValue aCell(mrDoc, aAdr);
3445 if (aCell.hasString())
3446 {
3447 svl::SharedString aSS;
3448 GetCellString(aSS, aCell);
3449 aInputString = aSS.getString();
3450 }
3451 else if (aCell.hasNumeric())
3452 {
3453 PushDouble( GetCellValue(aAdr, aCell) );
3454 return;
3455 }
3456 else
3457 {
3458 PushDouble(0.0);
3459 return;
3460 }
3461 }
3462 break;
3463 case svMatrix:
3464 {
3465 svl::SharedString aSS;
3466 ScMatValType nType = GetDoubleOrStringFromMatrix( fVal,
3467 aSS);
3468 aInputString = aSS.getString();
3469 switch (nType)
3470 {
3471 case ScMatValType::Empty:
3472 fVal = 0.0;
3473 [[fallthrough]];
3474 case ScMatValType::Value:
3475 case ScMatValType::Boolean:
3476 PushDouble( fVal);
3477 return;
3478 case ScMatValType::String:
3479 // evaluated below
3480 break;
3481 default:
3482 PushIllegalArgument();
3483 }
3484 }
3485 break;
3486 default:
3487 aInputString = GetString().getString();
3488 break;
3489 }
3490
3491 sal_uInt32 nFIndex = 0; // 0 for default locale
3492 if (mrContext.NFIsNumberFormat(aInputString, nFIndex, fVal))
3493 PushDouble(fVal);
3494 else
3495 PushIllegalArgument();
3496 }
3497
3498 // fdo#57180
3499 void ScInterpreter::ScNumberValue()
3500 {
3501
3502 sal_uInt8 nParamCount = GetByte();
3503 if ( !MustHaveParamCount( nParamCount, 1, 3 ) )
3504 return;
3505
3506 OUString aInputString;
3507 OUString aGroupSeparator;
3508 sal_Unicode cDecimalSeparator = 0;
3509
3510 if ( nParamCount == 3 )
3511 aGroupSeparator = GetString().getString();
3512
3513 if ( nParamCount >= 2 )
3514 {
3515 OUString aDecimalSeparator = GetString().getString();
3516 if ( aDecimalSeparator.getLength() == 1 )
3517 cDecimalSeparator = aDecimalSeparator[ 0 ];
3518 else
3519 {
3520 PushIllegalArgument(); //if given, separator length must be 1
3521 return;
3522 }
3523 }
3524
3525 if ( cDecimalSeparator && aGroupSeparator.indexOf( cDecimalSeparator ) != -1 )
3526 {
3527 PushIllegalArgument(); //decimal separator cannot appear in group separator
3528 return;
3529 }
3530
3531 switch (GetStackType())
3532 {
3533 case svDouble:
3534 return; // leave on stack
3535 default:
3536 aInputString = GetString().getString();
3537 }
3538 if ( nGlobalError != FormulaError::NONE )
3539 {
3540 PushError( nGlobalError );
3541 return;
3542 }
3543 if ( aInputString.isEmpty() )
3544 {
3545 if ( maCalcConfig.mbEmptyStringAsZero )
3546 PushDouble( 0.0 );
3547 else
3548 PushNoValue();
3549 return;
3550 }
3551
3552 sal_Int32 nDecSep = aInputString.indexOf( cDecimalSeparator );
3553 if ( nDecSep != 0 )
3554 {
3555 OUString aTemporary( nDecSep >= 0 ? aInputString.copy( 0, nDecSep ) : aInputString );
3556 sal_Int32 nIndex = 0;
3557 while (nIndex < aGroupSeparator.getLength())
3558 {
3559 sal_uInt32 nChar = aGroupSeparator.iterateCodePoints( &nIndex );
3560 aTemporary = aTemporary.replaceAll( OUString( &nChar, 1 ), "" );
3561 }
3562 if ( nDecSep >= 0 )
3563 aInputString = aTemporary + aInputString.subView( nDecSep );
3564 else
3565 aInputString = aTemporary;
3566 }
3567
3568 for ( sal_Int32 i = aInputString.getLength(); --i >= 0; )
3569 {
3570 sal_Unicode c = aInputString[ i ];
3571 if ( c == 0x0020 || c == 0x0009 || c == 0x000A || c == 0x000D )
3572 aInputString = aInputString.replaceAt( i, 1, u"" ); // remove spaces etc.
3573 }
3574 sal_Int32 nPercentCount = 0;
3575 for ( sal_Int32 i = aInputString.getLength() - 1; i >= 0 && aInputString[ i ] == 0x0025; i-- )
3576 {
3577 aInputString = aInputString.replaceAt( i, 1, u"" ); // remove and count trailing '%'
3578 nPercentCount++;
3579 }
3580
3581 rtl_math_ConversionStatus eStatus;
3582 sal_Int32 nParseEnd;
3583 double fVal = ::rtl::math::stringToDouble( aInputString, cDecimalSeparator, 0, &eStatus, &nParseEnd );
3584 if ( eStatus == rtl_math_ConversionStatus_Ok && nParseEnd == aInputString.getLength() )
3585 {
3586 if (nPercentCount)
3587 fVal *= pow( 10.0, -(nPercentCount * 2)); // process '%' from input string
3588 PushDouble(fVal);
3589 return;
3590 }
3591 PushNoValue();
3592 }
3593
3594 static bool lcl_ScInterpreter_IsPrintable( sal_uInt32 nCodePoint )
3595 {
3596 return ( !u_isISOControl(nCodePoint) /*not in Cc*/
3597 && u_isdefined(nCodePoint) /*not in Cn*/ );
3598 }
3599
3600
3601 void ScInterpreter::ScClean()
3602 {
3603 OUString aStr = GetString().getString();
3604
3605 OUStringBuffer aBuf( aStr.getLength() );
3606 sal_Int32 nIdx = 0;
3607 while ( nIdx < aStr.getLength() )
3608 {
3609 sal_uInt32 c = aStr.iterateCodePoints( &nIdx );
3610 if ( lcl_ScInterpreter_IsPrintable( c ) )
3611 aBuf.appendUtf32( c );
3612 }
3613 PushString( aBuf.makeStringAndClear() );
3614 }
3615
3616
3617 void ScInterpreter::ScCode()
3618 {
3619 //2do: make it full range unicode?
3620 OUString aStr = GetString().getString();
3621 if (aStr.isEmpty())
3622 PushInt(0);
3623 else
3624 {
3625 //"classic" ByteString conversion flags
3626 const sal_uInt32 convertFlags =
3627 RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE |
3628 RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE |
3629 RTL_UNICODETOTEXT_FLAGS_FLUSH |
3630 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |
3631 RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT |
3632 RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE;
3633 PushInt( static_cast<unsigned char>(OUStringToOString(OUStringChar(aStr[0]), osl_getThreadTextEncoding(), convertFlags).toChar()) );
3634 }
3635 }
3636
3637 void ScInterpreter::ScChar()
3638 {
3639 //2do: make it full range unicode?
3640 double fVal = GetDouble();
3641 if (fVal < 0.0 || fVal >= 256.0)
3642 PushIllegalArgument();
3643 else
3644 {
3645 //"classic" ByteString conversion flags
3646 const sal_uInt32 convertFlags =
3647 RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT |
3648 RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
3649 RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT;
3650
3651 char cEncodedChar = static_cast<char>(fVal);
3652 OUString aStr(&cEncodedChar, 1, osl_getThreadTextEncoding(), convertFlags);
3653 PushString(aStr);
3654 }
3655 }
3656
3657 /* #i70213# fullwidth/halfwidth conversion provided by
3658 * Takashi Nakamoto <bluedwarf@ooo>
3659 * erAck: added Excel compatibility conversions as seen in issue's test case. */
3660
3661 static OUString lcl_convertIntoHalfWidth( const OUString & rStr )
3662 {
3663 // Make the initialization thread-safe. Since another function needs to be called, move it all to another
3664 // function and thread-safely initialize a static reference in this function.
3665 auto init = []() -> utl::TransliterationWrapper&
3666 {
3667 static utl::TransliterationWrapper trans( ::comphelper::getProcessComponentContext(), TransliterationFlags::NONE );
3668 trans.loadModuleByImplName( u"FULLWIDTH_HALFWIDTH_LIKE_ASC"_ustr, LANGUAGE_SYSTEM );
3669 return trans;
3670 };
3671 static utl::TransliterationWrapper& aTrans( init());
3672 return aTrans.transliterate( rStr, 0, sal_uInt16( rStr.getLength() ) );
3673 }
3674
3675 static OUString lcl_convertIntoFullWidth( const OUString & rStr )
3676 {
3677 auto init = []() -> utl::TransliterationWrapper&
3678 {
3679 static utl::TransliterationWrapper trans( ::comphelper::getProcessComponentContext(), TransliterationFlags::NONE );
3680 trans.loadModuleByImplName( u"HALFWIDTH_FULLWIDTH_LIKE_JIS"_ustr, LANGUAGE_SYSTEM );
3681 return trans;
3682 };
3683 static utl::TransliterationWrapper& aTrans( init());
3684 return aTrans.transliterate( rStr, 0, sal_uInt16( rStr.getLength() ) );
3685 }
3686
3687 /* ODFF:
3688 * Summary: Converts half-width to full-width ASCII and katakana characters.
3689 * Semantics: Conversion is done for half-width ASCII and katakana characters,
3690 * other characters are simply copied from T to the result. This is the
3691 * complementary function to ASC.
3692 * For references regarding halfwidth and fullwidth characters see
3693 * http://www.unicode.org/reports/tr11/
3694 * http://www.unicode.org/charts/charindex2.html#H
3695 * http://www.unicode.org/charts/charindex2.html#F
3696 */
3697 void ScInterpreter::ScJis()
3698 {
3699 if (MustHaveParamCount( GetByte(), 1))
3700 PushString( lcl_convertIntoFullWidth( GetString().getString()));
3701 }
3702
3703 /* ODFF:
3704 * Summary: Converts full-width to half-width ASCII and katakana characters.
3705 * Semantics: Conversion is done for full-width ASCII and katakana characters,
3706 * other characters are simply copied from T to the result. This is the
3707 * complementary function to JIS.
3708 */
3709 void ScInterpreter::ScAsc()
3710 {
3711 if (MustHaveParamCount( GetByte(), 1))
3712 PushString( lcl_convertIntoHalfWidth( GetString().getString()));
3713 }
3714
3715 void ScInterpreter::ScUnicode()
3716 {
3717 if ( MustHaveParamCount( GetByte(), 1 ) )
3718 {
3719 OUString aStr = GetString().getString();
3720 if (aStr.isEmpty())
3721 PushIllegalParameter();
3722 else
3723 {
3724 PushDouble(aStr.iterateCodePoints(&o3tl::temporary(sal_Int32(0))));
3725 }
3726 }
3727 }
3728
3729 void ScInterpreter::ScUnichar()
3730 {
3731 if ( MustHaveParamCount( GetByte(), 1 ) )
3732 {
3733 sal_uInt32 nCodePoint = GetUInt32();
3734 if (nGlobalError != FormulaError::NONE || !rtl::isUnicodeCodePoint(nCodePoint))
3735 PushIllegalArgument();
3736 else
3737 {
3738 OUString aStr( &nCodePoint, 1 );
3739 PushString( aStr );
3740 }
3741 }
3742 }
3743
3744 bool ScInterpreter::SwitchToArrayRefList( ScMatrixRef& xResMat, SCSIZE nMatRows, double fCurrent,
3745 const std::function<void( SCSIZE i, double fCurrent )>& MatOpFunc, bool bDoMatOp )
3746 {
3747 const ScRefListToken* p = dynamic_cast<const ScRefListToken*>(pStack[sp-1]);
3748 if (!p || !p->IsArrayResult())
3749 return false;
3750
3751 if (!xResMat)
3752 {
3753 // Create and init all elements with current value.
3754 assert(nMatRows > 0);
3755 xResMat = GetNewMat( 1, nMatRows, true);
3756 xResMat->FillDouble( fCurrent, 0,0, 0,nMatRows-1);
3757 }
3758 else if (bDoMatOp)
3759 {
3760 // Current value and values from vector are operands
3761 // for each vector position.
3762 for (SCSIZE i=0; i < nMatRows; ++i)
3763 {
3764 MatOpFunc( i, fCurrent);
3765 }
3766 }
3767 return true;
3768 }
3769
3770 void ScInterpreter::ScMin( bool bTextAsZero )
3771 {
3772 short nParamCount = GetByte();
3773 if (!MustHaveParamCountMin( nParamCount, 1))
3774 return;
3775
3776 ScMatrixRef xResMat;
3777 double nMin = ::std::numeric_limits<double>::max();
3778 auto MatOpFunc = [&xResMat]( SCSIZE i, double fCurMin )
3779 {
3780 double fVecRes = xResMat->GetDouble(0,i);
3781 if (fVecRes > fCurMin)
3782 xResMat->PutDouble( fCurMin, 0,i);
3783 };
3784 const SCSIZE nMatRows = GetRefListArrayMaxSize( nParamCount);
3785 size_t nRefArrayPos = std::numeric_limits<size_t>::max();
3786
3787 double nVal = 0.0;
3788 ScAddress aAdr;
3789 ScRange aRange;
3790 size_t nRefInList = 0;
3791 while (nParamCount-- > 0)
3792 {
3793 switch (GetStackType())
3794 {
3795 case svDouble :
3796 {
3797 nVal = GetDouble();
3798 if (nMin > nVal) nMin = nVal;
3799 nFuncFmtType = SvNumFormatType::NUMBER;
3800 }
3801 break;
3802 case svSingleRef :
3803 {
3804 PopSingleRef( aAdr );
3805 ScRefCellValue aCell(mrDoc, aAdr);
3806 if (aCell.hasNumeric())
3807 {
3808 nVal = GetCellValue(aAdr, aCell);
3809 CurFmtToFuncFmt();
3810 if (nMin > nVal) nMin = nVal;
3811 }
3812 else if (bTextAsZero && aCell.hasString())
3813 {
3814 if ( nMin > 0.0 )
3815 nMin = 0.0;
3816 }
3817 }
3818 break;
3819 case svRefList :
3820 {
3821 // bDoMatOp only for non-array value when switching to
3822 // ArrayRefList.
3823 if (SwitchToArrayRefList( xResMat, nMatRows, nMin, MatOpFunc,
3824 nRefArrayPos == std::numeric_limits<size_t>::max()))
3825 {
3826 nRefArrayPos = nRefInList;
3827 }
3828 }
3829 [[fallthrough]];
3830 case svDoubleRef :
3831 {
3832 FormulaError nErr = FormulaError::NONE;
3833 PopDoubleRef( aRange, nParamCount, nRefInList);
3834 ScValueIterator aValIter( mrContext, aRange, mnSubTotalFlags, bTextAsZero );
3835 if (aValIter.GetFirst(nVal, nErr))
3836 {
3837 if (nMin > nVal)
3838 nMin = nVal;
3839 aValIter.GetCurNumFmtInfo( nFuncFmtType, nFuncFmtIndex );
3840 while ((nErr == FormulaError::NONE) && aValIter.GetNext(nVal, nErr))
3841 {
3842 if (nMin > nVal)
3843 nMin = nVal;
3844 }
3845 SetError(nErr);
3846 }
3847 if (nRefArrayPos != std::numeric_limits<size_t>::max())
3848 {
3849 // Update vector element with current value.
3850 MatOpFunc( nRefArrayPos, nMin);
3851
3852 // Reset.
3853 nMin = std::numeric_limits<double>::max();
3854 nVal = 0.0;
3855 nRefArrayPos = std::numeric_limits<size_t>::max();
3856 }
3857 }
3858 break;
3859 case svMatrix :
3860 case svExternalSingleRef:
3861 case svExternalDoubleRef:
3862 {
3863 ScMatrixRef pMat = GetMatrix();
3864 if (pMat)
3865 {
3866 nFuncFmtType = SvNumFormatType::NUMBER;
3867 nVal = pMat->GetMinValue(bTextAsZero, bool(mnSubTotalFlags & SubtotalFlags::IgnoreErrVal));
3868 if (nMin > nVal)
3869 nMin = nVal;
3870 }
3871 }
3872 break;
3873 case svString :
3874 {
3875 Pop();
3876 if ( bTextAsZero )
3877 {
3878 if ( nMin > 0.0 )
3879 nMin = 0.0;
3880 }
3881 else
3882 SetError(FormulaError::IllegalParameter);
3883 }
3884 break;
3885 default :
3886 PopError();
3887 SetError(FormulaError::IllegalParameter);
3888 }
3889 }
3890
3891 if (xResMat)
3892 {
3893 // Include value of last non-references-array type and calculate final result.
3894 if (nMin < std::numeric_limits<double>::max())
3895 {
3896 for (SCSIZE i=0; i < nMatRows; ++i)
3897 {
3898 MatOpFunc( i, nMin);
3899 }
3900 }
3901 else
3902 {
3903 /* TODO: the awkward "no value is minimum 0.0" is likely the case
3904 * if a value is numeric_limits::max. Still, that could be a valid
3905 * minimum value as well, but nVal and nMin had been reset after
3906 * the last svRefList... so we may lie here. */
3907 for (SCSIZE i=0; i < nMatRows; ++i)
3908 {
3909 double fVecRes = xResMat->GetDouble(0,i);
3910 if (fVecRes == std::numeric_limits<double>::max())
3911 xResMat->PutDouble( 0.0, 0,i);
3912 }
3913 }
3914 PushMatrix( xResMat);
3915 }
3916 else
3917 {
3918 if (!std::isfinite(nVal))
3919 PushError( GetDoubleErrorValue( nVal));
3920 else if ( nVal < nMin )
3921 PushDouble(0.0); // zero or only empty arguments
3922 else
3923 PushDouble(nMin);
3924 }
3925 }
3926
3927 void ScInterpreter::ScMax( bool bTextAsZero )
3928 {
3929 short nParamCount = GetByte();
3930 if (!MustHaveParamCountMin( nParamCount, 1))
3931 return;
3932
3933 ScMatrixRef xResMat;
3934 double nMax = std::numeric_limits<double>::lowest();
3935 auto MatOpFunc = [&xResMat]( SCSIZE i, double fCurMax )
3936 {
3937 double fVecRes = xResMat->GetDouble(0,i);
3938 if (fVecRes < fCurMax)
3939 xResMat->PutDouble( fCurMax, 0,i);
3940 };
3941 const SCSIZE nMatRows = GetRefListArrayMaxSize( nParamCount);
3942 size_t nRefArrayPos = std::numeric_limits<size_t>::max();
3943
3944 double nVal = 0.0;
3945 ScAddress aAdr;
3946 ScRange aRange;
3947 size_t nRefInList = 0;
3948 while (nParamCount-- > 0)
3949 {
3950 switch (GetStackType())
3951 {
3952 case svDouble :
3953 {
3954 nVal = GetDouble();
3955 if (nMax < nVal) nMax = nVal;
3956 nFuncFmtType = SvNumFormatType::NUMBER;
3957 }
3958 break;
3959 case svSingleRef :
3960 {
3961 PopSingleRef( aAdr );
3962 ScRefCellValue aCell(mrDoc, aAdr);
3963 if (aCell.hasNumeric())
3964 {
3965 nVal = GetCellValue(aAdr, aCell);
3966 CurFmtToFuncFmt();
3967 if (nMax < nVal) nMax = nVal;
3968 }
3969 else if (bTextAsZero && aCell.hasString())
3970 {
3971 if ( nMax < 0.0 )
3972 nMax = 0.0;
3973 }
3974 }
3975 break;
3976 case svRefList :
3977 {
3978 // bDoMatOp only for non-array value when switching to
3979 // ArrayRefList.
3980 if (SwitchToArrayRefList( xResMat, nMatRows, nMax, MatOpFunc,
3981 nRefArrayPos == std::numeric_limits<size_t>::max()))
3982 {
3983 nRefArrayPos = nRefInList;
3984 }
3985 }
3986 [[fallthrough]];
3987 case svDoubleRef :
3988 {
3989 FormulaError nErr = FormulaError::NONE;
3990 PopDoubleRef( aRange, nParamCount, nRefInList);
3991 ScValueIterator aValIter( mrContext, aRange, mnSubTotalFlags, bTextAsZero );
3992 if (aValIter.GetFirst(nVal, nErr))
3993 {
3994 if (nMax < nVal)
3995 nMax = nVal;
3996 aValIter.GetCurNumFmtInfo( nFuncFmtType, nFuncFmtIndex );
3997 while ((nErr == FormulaError::NONE) && aValIter.GetNext(nVal, nErr))
3998 {
3999 if (nMax < nVal)
4000 nMax = nVal;
4001 }
4002 SetError(nErr);
4003 }
4004 if (nRefArrayPos != std::numeric_limits<size_t>::max())
4005 {
4006 // Update vector element with current value.
4007 MatOpFunc( nRefArrayPos, nMax);
4008
4009 // Reset.
4010 nMax = std::numeric_limits<double>::lowest();
4011 nVal = 0.0;
4012 nRefArrayPos = std::numeric_limits<size_t>::max();
4013 }
4014 }
4015 break;
4016 case svMatrix :
4017 case svExternalSingleRef:
4018 case svExternalDoubleRef:
4019 {
4020 ScMatrixRef pMat = GetMatrix();
4021 if (pMat)
4022 {
4023 nFuncFmtType = SvNumFormatType::NUMBER;
4024 nVal = pMat->GetMaxValue(bTextAsZero, bool(mnSubTotalFlags & SubtotalFlags::IgnoreErrVal));
4025 if (nMax < nVal)
4026 nMax = nVal;
4027 }
4028 }
4029 break;
4030 case svString :
4031 {
4032 Pop();
4033 if ( bTextAsZero )
4034 {
4035 if ( nMax < 0.0 )
4036 nMax = 0.0;
4037 }
4038 else
4039 SetError(FormulaError::IllegalParameter);
4040 }
4041 break;
4042 default :
4043 PopError();
4044 SetError(FormulaError::IllegalParameter);
4045 }
4046 }
4047
4048 if (xResMat)
4049 {
4050 // Include value of last non-references-array type and calculate final result.
4051 if (nMax > std::numeric_limits<double>::lowest())
4052 {
4053 for (SCSIZE i=0; i < nMatRows; ++i)
4054 {
4055 MatOpFunc( i, nMax);
4056 }
4057 }
4058 else
4059 {
4060 /* TODO: the awkward "no value is maximum 0.0" is likely the case
4061 * if a value is numeric_limits::lowest. Still, that could be a
4062 * valid maximum value as well, but nVal and nMax had been reset
4063 * after the last svRefList... so we may lie here. */
4064 for (SCSIZE i=0; i < nMatRows; ++i)
4065 {
4066 double fVecRes = xResMat->GetDouble(0,i);
4067 if (fVecRes == -std::numeric_limits<double>::max())
4068 xResMat->PutDouble( 0.0, 0,i);
4069 }
4070 }
4071 PushMatrix( xResMat);
4072 }
4073 else
4074 {
4075 if (!std::isfinite(nVal))
4076 PushError( GetDoubleErrorValue( nVal));
4077 else if ( nVal > nMax )
4078 PushDouble(0.0); // zero or only empty arguments
4079 else
4080 PushDouble(nMax);
4081 }
4082 }
4083
4084 void ScInterpreter::GetStVarParams( bool bTextAsZero, double(*VarResult)( double fVal, size_t nValCount ) )
4085 {
4086 short nParamCount = GetByte();
4087 const SCSIZE nMatRows = GetRefListArrayMaxSize( nParamCount);
4088
4089 struct ArrayRefListValue
4090 {
4091 std::vector<double> mvValues;
4092 KahanSum mfSum;
4093 ArrayRefListValue() = default;
4094 double get() const { return mfSum.get(); }
4095 };
4096 std::vector<ArrayRefListValue> vArrayValues;
4097
4098 std::vector<double> values;
4099 KahanSum fSum = 0.0;
4100 double fVal = 0.0;
4101 ScAddress aAdr;
4102 ScRange aRange;
4103 size_t nRefInList = 0;
4104 while (nGlobalError == FormulaError::NONE && nParamCount-- > 0)
4105 {
4106 switch (GetStackType())
4107 {
4108 case svDouble :
4109 {
4110 fVal = GetDouble();
4111 if (nGlobalError == FormulaError::NONE)
4112 {
4113 values.push_back(fVal);
4114 fSum += fVal;
4115 }
4116 }
4117 break;
4118 case svSingleRef :
4119 {
4120 PopSingleRef( aAdr );
4121 ScRefCellValue aCell(mrDoc, aAdr);
4122 if (aCell.hasNumeric())
4123 {
4124 fVal = GetCellValue(aAdr, aCell);
4125 if (nGlobalError == FormulaError::NONE)
4126 {
4127 values.push_back(fVal);
4128 fSum += fVal;
4129 }
4130 }
4131 else if (bTextAsZero && aCell.hasString())
4132 {
4133 values.push_back(0.0);
4134 }
4135 }
4136 break;
4137 case svRefList :
4138 {
4139 const ScRefListToken* p = dynamic_cast<const ScRefListToken*>(pStack[sp-1]);
4140 if (p && p->IsArrayResult())
4141 {
4142 size_t nRefArrayPos = nRefInList;
4143 if (vArrayValues.empty())
4144 {
4145 // Create and init all elements with current value.
4146 assert(nMatRows > 0);
4147 vArrayValues.resize(nMatRows);
4148 for (ArrayRefListValue & it : vArrayValues)
4149 {
4150 it.mvValues = values;
4151 it.mfSum = fSum;
4152 }
4153 }
4154 else
4155 {
4156 // Current value and values from vector are operands
4157 // for each vector position.
4158 for (ArrayRefListValue & it : vArrayValues)
4159 {
4160 it.mvValues.insert( it.mvValues.end(), values.begin(), values.end());
4161 it.mfSum += fSum;
4162 }
4163 }
4164 ArrayRefListValue& rArrayValue = vArrayValues[nRefArrayPos];
4165 FormulaError nErr = FormulaError::NONE;
4166 PopDoubleRef( aRange, nParamCount, nRefInList);
4167 ScValueIterator aValIter( mrContext, aRange, mnSubTotalFlags, bTextAsZero );
4168 if (aValIter.GetFirst(fVal, nErr))
4169 {
4170 do
4171 {
4172 rArrayValue.mvValues.push_back(fVal);
4173 rArrayValue.mfSum += fVal;
4174 }
4175 while ((nErr == FormulaError::NONE) && aValIter.GetNext(fVal, nErr));
4176 }
4177 if ( nErr != FormulaError::NONE )
4178 {
4179 rArrayValue.mfSum = CreateDoubleError( nErr);
4180 }
4181 // Reset.
4182 std::vector<double>().swap(values);
4183 fSum = 0.0;
4184 break;
4185 }
4186 }
4187 [[fallthrough]];
4188 case svDoubleRef :
4189 {
4190 FormulaError nErr = FormulaError::NONE;
4191 PopDoubleRef( aRange, nParamCount, nRefInList);
4192 ScValueIterator aValIter( mrContext, aRange, mnSubTotalFlags, bTextAsZero );
4193 if (aValIter.GetFirst(fVal, nErr))
4194 {
4195 do
4196 {
4197 values.push_back(fVal);
4198 fSum += fVal;
4199 }
4200 while ((nErr == FormulaError::NONE) && aValIter.GetNext(fVal, nErr));
4201 }
4202 if ( nErr != FormulaError::NONE )
4203 {
4204 SetError(nErr);
4205 }
4206 }
4207 break;
4208 case svExternalSingleRef :
4209 case svExternalDoubleRef :
4210 case svMatrix :
4211 {
4212 ScMatrixRef pMat = GetMatrix();
4213 if (pMat)
4214 {
4215 const bool bIgnoreErrVal = bool(mnSubTotalFlags & SubtotalFlags::IgnoreErrVal);
4216 SCSIZE nC, nR;
4217 pMat->GetDimensions(nC, nR);
4218 for (SCSIZE nMatCol = 0; nMatCol < nC; nMatCol++)
4219 {
4220 for (SCSIZE nMatRow = 0; nMatRow < nR; nMatRow++)
4221 {
4222 if (!pMat->IsStringOrEmpty(nMatCol,nMatRow))
4223 {
4224 fVal= pMat->GetDouble(nMatCol,nMatRow);
4225 if (nGlobalError == FormulaError::NONE)
4226 {
4227 values.push_back(fVal);
4228 fSum += fVal;
4229 }
4230 else if (bIgnoreErrVal)
4231 nGlobalError = FormulaError::NONE;
4232 }
4233 else if ( bTextAsZero )
4234 {
4235 values.push_back(0.0);
4236 }
4237 }
4238 }
4239 }
4240 }
4241 break;
4242 case svString :
4243 {
4244 Pop();
4245 if ( bTextAsZero )
4246 {
4247 values.push_back(0.0);
4248 }
4249 else
4250 SetError(FormulaError::IllegalParameter);
4251 }
4252 break;
4253 default :
4254 PopError();
4255 SetError(FormulaError::IllegalParameter);
4256 }
4257 }
4258
4259 if (!vArrayValues.empty())
4260 {
4261 // Include value of last non-references-array type and calculate final result.
4262 if (!values.empty())
4263 {
4264 for (auto & it : vArrayValues)
4265 {
4266 it.mvValues.insert( it.mvValues.end(), values.begin(), values.end());
4267 it.mfSum += fSum;
4268 }
4269 }
4270 ScMatrixRef xResMat = GetNewMat( 1, nMatRows, true);
4271 for (SCSIZE r=0; r < nMatRows; ++r)
4272 {
4273 ::std::vector<double>::size_type n = vArrayValues[r].mvValues.size();
4274 if (!n)
4275 xResMat->PutError( FormulaError::DivisionByZero, 0, r);
4276 else
4277 {
4278 ArrayRefListValue& rArrayValue = vArrayValues[r];
4279 double vSum = 0.0;
4280 const double vMean = rArrayValue.get() / n;
4281 for (::std::vector<double>::size_type i = 0; i < n; i++)
4282 vSum += ::rtl::math::approxSub( rArrayValue.mvValues[i], vMean) *
4283 ::rtl::math::approxSub( rArrayValue.mvValues[i], vMean);
4284 xResMat->PutDouble( VarResult( vSum, n), 0, r);
4285 }
4286 }
4287 PushMatrix( xResMat);
4288 }
4289 else
4290 {
4291 ::std::vector<double>::size_type n = values.size();
4292 if (!n)
4293 SetError( FormulaError::DivisionByZero);
4294 double vSum = 0.0;
4295 if (nGlobalError == FormulaError::NONE)
4296 {
4297 const double vMean = fSum.get() / n;
4298 for (::std::vector<double>::size_type i = 0; i < n; i++)
4299 vSum += ::rtl::math::approxSub( values[i], vMean) * ::rtl::math::approxSub( values[i], vMean);
4300 }
4301 PushDouble( VarResult( vSum, n));
4302 }
4303 }
4304
4305 void ScInterpreter::ScVar( bool bTextAsZero )
4306 {
4307 auto VarResult = []( double fVal, size_t nValCount )
4308 {
4309 if (nValCount <= 1)
4310 return CreateDoubleError( FormulaError::DivisionByZero );
4311 else
4312 return fVal / (nValCount - 1);
4313 };
4314 GetStVarParams( bTextAsZero, VarResult );
4315 }
4316
4317 void ScInterpreter::ScVarP( bool bTextAsZero )
4318 {
4319 auto VarResult = []( double fVal, size_t nValCount )
4320 {
4321 return sc::div( fVal, nValCount);
4322 };
4323 GetStVarParams( bTextAsZero, VarResult );
4324
4325 }
4326
4327 void ScInterpreter::ScStDev( bool bTextAsZero )
4328 {
4329 auto VarResult = []( double fVal, size_t nValCount )
4330 {
4331 if (nValCount <= 1)
4332 return CreateDoubleError( FormulaError::DivisionByZero );
4333 else
4334 return sqrt( fVal / (nValCount - 1));
4335 };
4336 GetStVarParams( bTextAsZero, VarResult );
4337 }
4338
4339 void ScInterpreter::ScStDevP( bool bTextAsZero )
4340 {
4341 auto VarResult = []( double fVal, size_t nValCount )
4342 {
4343 if (nValCount == 0)
4344 return CreateDoubleError( FormulaError::DivisionByZero );
4345 else
4346 return sqrt( fVal / nValCount);
4347 };
4348 GetStVarParams( bTextAsZero, VarResult );
4349
4350 /* this was: PushDouble( sqrt( div( nVal, nValCount)));
4351 *
4352 * Besides that the special NAN gets lost in the call through sqrt(),
4353 * unxlngi6.pro then looped back and forth somewhere between div() and
4354 * ::rtl::math::setNan(). Tests showed that
4355 *
4356 * sqrt( div( 1, 0));
4357 *
4358 * produced a loop, but
4359 *
4360 * double f1 = div( 1, 0);
4361 * sqrt( f1 );
4362 *
4363 * was fine. There seems to be some compiler optimization problem. It does
4364 * not occur when compiled with debug=t.
4365 */
4366 }
4367
4368 void ScInterpreter::ScColumns()
4369 {
4370 sal_uInt8 nParamCount = GetByte();
4371 sal_uLong nVal = 0;
4372 SCCOL nCol1;
4373 SCROW nRow1;
4374 SCTAB nTab1;
4375 SCCOL nCol2;
4376 SCROW nRow2;
4377 SCTAB nTab2;
4378 while (nParamCount-- > 0)
4379 {
4380 switch ( GetStackType() )
4381 {
4382 case svSingleRef:
4383 PopError();
4384 nVal++;
4385 break;
4386 case svDoubleRef:
4387 PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
4388 nVal += static_cast<sal_uLong>(nTab2 - nTab1 + 1) *
4389 static_cast<sal_uLong>(nCol2 - nCol1 + 1);
4390 break;
4391 case svMatrix:
4392 {
4393 ScMatrixRef pMat = PopMatrix();
4394 if (pMat)
4395 {
4396 SCSIZE nC, nR;
4397 pMat->GetDimensions(nC, nR);
4398 nVal += nC;
4399 }
4400 }
4401 break;
4402 case svExternalSingleRef:
4403 PopError();
4404 nVal++;
4405 break;
4406 case svExternalDoubleRef:
4407 {
4408 sal_uInt16 nFileId;
4409 OUString aTabName;
4410 ScComplexRefData aRef;
4411 PopExternalDoubleRef( nFileId, aTabName, aRef);
4412 ScRange aAbs = aRef.toAbs(mrDoc, aPos);
4413 nVal += static_cast<sal_uLong>(aAbs.aEnd.Tab() - aAbs.aStart.Tab() + 1) *
4414 static_cast<sal_uLong>(aAbs.aEnd.Col() - aAbs.aStart.Col() + 1);
4415 }
4416 break;
4417 default:
4418 PopError();
4419 SetError(FormulaError::IllegalParameter);
4420 }
4421 }
4422 PushDouble(static_cast<double>(nVal));
4423 }
4424
4425 void ScInterpreter::ScRows()
4426 {
4427 sal_uInt8 nParamCount = GetByte();
4428 sal_uLong nVal = 0;
4429 SCCOL nCol1;
4430 SCROW nRow1;
4431 SCTAB nTab1;
4432 SCCOL nCol2;
4433 SCROW nRow2;
4434 SCTAB nTab2;
4435 while (nParamCount-- > 0)
4436 {
4437 switch ( GetStackType() )
4438 {
4439 case svSingleRef:
4440 PopError();
4441 nVal++;
4442 break;
4443 case svDoubleRef:
4444 PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
4445 nVal += static_cast<sal_uLong>(nTab2 - nTab1 + 1) *
4446 static_cast<sal_uLong>(nRow2 - nRow1 + 1);
4447 break;
4448 case svMatrix:
4449 {
4450 ScMatrixRef pMat = PopMatrix();
4451 if (pMat)
4452 {
4453 SCSIZE nC, nR;
4454 pMat->GetDimensions(nC, nR);
4455 nVal += nR;
4456 }
4457 }
4458 break;
4459 case svExternalSingleRef:
4460 PopError();
4461 nVal++;
4462 break;
4463 case svExternalDoubleRef:
4464 {
4465 sal_uInt16 nFileId;
4466 OUString aTabName;
4467 ScComplexRefData aRef;
4468 PopExternalDoubleRef( nFileId, aTabName, aRef);
4469 ScRange aAbs = aRef.toAbs(mrDoc, aPos);
4470 nVal += static_cast<sal_uLong>(aAbs.aEnd.Tab() - aAbs.aStart.Tab() + 1) *
4471 static_cast<sal_uLong>(aAbs.aEnd.Row() - aAbs.aStart.Row() + 1);
4472 }
4473 break;
4474 default:
4475 PopError();
4476 SetError(FormulaError::IllegalParameter);
4477 }
4478 }
4479 PushDouble(static_cast<double>(nVal));
4480 }
4481
4482 void ScInterpreter::ScSheets()
4483 {
4484 sal_uInt8 nParamCount = GetByte();
4485 sal_uLong nVal;
4486 if ( nParamCount == 0 )
4487 nVal = mrDoc.GetTableCount();
4488 else
4489 {
4490 nVal = 0;
4491 SCCOL nCol1;
4492 SCROW nRow1;
4493 SCTAB nTab1;
4494 SCCOL nCol2;
4495 SCROW nRow2;
4496 SCTAB nTab2;
4497 while (nGlobalError == FormulaError::NONE && nParamCount-- > 0)
4498 {
4499 switch ( GetStackType() )
4500 {
4501 case svSingleRef:
4502 case svExternalSingleRef:
4503 PopError();
4504 nVal++;
4505 break;
4506 case svDoubleRef:
4507 PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
4508 nVal += static_cast<sal_uLong>(nTab2 - nTab1 + 1);
4509 break;
4510 case svExternalDoubleRef:
4511 {
4512 sal_uInt16 nFileId;
4513 OUString aTabName;
4514 ScComplexRefData aRef;
4515 PopExternalDoubleRef( nFileId, aTabName, aRef);
4516 ScRange aAbs = aRef.toAbs(mrDoc, aPos);
4517 nVal += static_cast<sal_uLong>(aAbs.aEnd.Tab() - aAbs.aStart.Tab() + 1);
4518 }
4519 break;
4520 default:
4521 PopError();
4522 SetError( FormulaError::IllegalParameter );
4523 }
4524 }
4525 }
4526 PushDouble( static_cast<double>(nVal) );
4527 }
4528
4529 void ScInterpreter::ScColumn()
4530 {
4531 sal_uInt8 nParamCount = GetByte();
4532 if ( !MustHaveParamCount( nParamCount, 0, 1 ) )
4533 return;
4534
4535 double nVal = 0.0;
4536 if (nParamCount == 0)
4537 {
4538 nVal = aPos.Col() + 1;
4539 if (bMatrixFormula)
4540 {
4541 SCCOL nCols = 0;
4542 SCROW nRows = 0;
4543 if (pMyFormulaCell)
4544 pMyFormulaCell->GetMatColsRows( nCols, nRows);
4545 bool bMayBeScalar;
4546 if (nCols == 0)
4547 {
4548 // Happens if called via ScViewFunc::EnterMatrix()
4549 // ScFormulaCell::GetResultDimensions() as of course a
4550 // matrix result is not available yet.
4551 nCols = 1;
4552 bMayBeScalar = false;
4553 }
4554 else
4555 {
4556 bMayBeScalar = true;
4557 }
4558 if (!bMayBeScalar || nCols != 1 || nRows != 1)
4559 {
4560 ScMatrixRef pResMat = GetNewMat( static_cast<SCSIZE>(nCols), 1, /*bEmpty*/true );
4561 if (pResMat)
4562 {
4563 for (SCCOL i=0; i < nCols; ++i)
4564 pResMat->PutDouble( nVal + i, static_cast<SCSIZE>(i), 0);
4565 PushMatrix( pResMat);
4566 return;
4567 }
4568 }
4569 }
4570 }
4571 else
4572 {
4573 switch ( GetStackType() )
4574 {
4575 case svSingleRef :
4576 {
4577 SCCOL nCol1(0);
4578 SCROW nRow1(0);
4579 SCTAB nTab1(0);
4580 PopSingleRef( nCol1, nRow1, nTab1 );
4581 nVal = static_cast<double>(nCol1 + 1);
4582 }
4583 break;
4584 case svExternalSingleRef :
4585 {
4586 sal_uInt16 nFileId;
4587 OUString aTabName;
4588 ScSingleRefData aRef;
4589 PopExternalSingleRef( nFileId, aTabName, aRef );
4590 ScAddress aAbsRef = aRef.toAbs(mrDoc, aPos);
4591 nVal = static_cast<double>( aAbsRef.Col() + 1 );
4592 }
4593 break;
4594
4595 case svDoubleRef :
4596 case svExternalDoubleRef :
4597 {
4598 SCCOL nCol1;
4599 SCCOL nCol2;
4600 if ( GetStackType() == svDoubleRef )
4601 {
4602 SCROW nRow1;
4603 SCTAB nTab1;
4604 SCROW nRow2;
4605 SCTAB nTab2;
4606 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
4607 }
4608 else
4609 {
4610 sal_uInt16 nFileId;
4611 OUString aTabName;
4612 ScComplexRefData aRef;
4613 PopExternalDoubleRef( nFileId, aTabName, aRef );
4614 ScRange aAbs = aRef.toAbs(mrDoc, aPos);
4615 nCol1 = aAbs.aStart.Col();
4616 nCol2 = aAbs.aEnd.Col();
4617 }
4618 if (nCol2 > nCol1)
4619 {
4620 ScMatrixRef pResMat = GetNewMat(
4621 static_cast<SCSIZE>(nCol2-nCol1+1), 1, /*bEmpty*/true);
4622 if (pResMat)
4623 {
4624 for (SCCOL i = nCol1; i <= nCol2; i++)
4625 pResMat->PutDouble(static_cast<double>(i+1),
4626 static_cast<SCSIZE>(i-nCol1), 0);
4627 PushMatrix(pResMat);
4628 return;
4629 }
4630 }
4631 else
4632 nVal = static_cast<double>(nCol1 + 1);
4633 }
4634 break;
4635 default:
4636 SetError( FormulaError::IllegalParameter );
4637 }
4638 }
4639 PushDouble( nVal );
4640 }
4641
4642 void ScInterpreter::ScRow()
4643 {
4644 sal_uInt8 nParamCount = GetByte();
4645 if ( !MustHaveParamCount( nParamCount, 0, 1 ) )
4646 return;
4647
4648 double nVal = 0.0;
4649 if (nParamCount == 0)
4650 {
4651 nVal = aPos.Row() + 1;
4652 if (bMatrixFormula)
4653 {
4654 SCCOL nCols = 0;
4655 SCROW nRows = 0;
4656 if (pMyFormulaCell)
4657 pMyFormulaCell->GetMatColsRows( nCols, nRows);
4658 bool bMayBeScalar;
4659 if (nRows == 0)
4660 {
4661 // Happens if called via ScViewFunc::EnterMatrix()
4662 // ScFormulaCell::GetResultDimensions() as of course a
4663 // matrix result is not available yet.
4664 nRows = 1;
4665 bMayBeScalar = false;
4666 }
4667 else
4668 {
4669 bMayBeScalar = true;
4670 }
4671 if (!bMayBeScalar || nCols != 1 || nRows != 1)
4672 {
4673 ScMatrixRef pResMat = GetNewMat( 1, static_cast<SCSIZE>(nRows), /*bEmpty*/true);
4674 if (pResMat)
4675 {
4676 for (SCROW i=0; i < nRows; i++)
4677 pResMat->PutDouble( nVal + i, 0, static_cast<SCSIZE>(i));
4678 PushMatrix( pResMat);
4679 return;
4680 }
4681 }
4682 }
4683 }
4684 else
4685 {
4686 switch ( GetStackType() )
4687 {
4688 case svSingleRef :
4689 {
4690 SCCOL nCol1(0);
4691 SCROW nRow1(0);
4692 SCTAB nTab1(0);
4693 PopSingleRef( nCol1, nRow1, nTab1 );
4694 nVal = static_cast<double>(nRow1 + 1);
4695 }
4696 break;
4697 case svExternalSingleRef :
4698 {
4699 sal_uInt16 nFileId;
4700 OUString aTabName;
4701 ScSingleRefData aRef;
4702 PopExternalSingleRef( nFileId, aTabName, aRef );
4703 ScAddress aAbsRef = aRef.toAbs(mrDoc, aPos);
4704 nVal = static_cast<double>( aAbsRef.Row() + 1 );
4705 }
4706 break;
4707 case svDoubleRef :
4708 case svExternalDoubleRef :
4709 {
4710 SCROW nRow1;
4711 SCROW nRow2;
4712 if ( GetStackType() == svDoubleRef )
4713 {
4714 SCCOL nCol1;
4715 SCTAB nTab1;
4716 SCCOL nCol2;
4717 SCTAB nTab2;
4718 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
4719 }
4720 else
4721 {
4722 sal_uInt16 nFileId;
4723 OUString aTabName;
4724 ScComplexRefData aRef;
4725 PopExternalDoubleRef( nFileId, aTabName, aRef );
4726 ScRange aAbs = aRef.toAbs(mrDoc, aPos);
4727 nRow1 = aAbs.aStart.Row();
4728 nRow2 = aAbs.aEnd.Row();
4729 }
4730 if (nRow2 > nRow1)
4731 {
4732 ScMatrixRef pResMat = GetNewMat( 1,
4733 static_cast<SCSIZE>(nRow2-nRow1+1), /*bEmpty*/true);
4734 if (pResMat)
4735 {
4736 for (SCROW i = nRow1; i <= nRow2; i++)
4737 pResMat->PutDouble(static_cast<double>(i+1), 0,
4738 static_cast<SCSIZE>(i-nRow1));
4739 PushMatrix(pResMat);
4740 return;
4741 }
4742 }
4743 else
4744 nVal = static_cast<double>(nRow1 + 1);
4745 }
4746 break;
4747 default:
4748 SetError( FormulaError::IllegalParameter );
4749 }
4750 }
4751 PushDouble( nVal );
4752 }
4753
4754 void ScInterpreter::ScSheet()
4755 {
4756 sal_uInt8 nParamCount = GetByte();
4757 if ( !MustHaveParamCount( nParamCount, 0, 1 ) )
4758 return;
4759
4760 SCTAB nVal = 0;
4761 if ( nParamCount == 0 )
4762 nVal = aPos.Tab() + 1;
4763 else
4764 {
4765 switch ( GetStackType() )
4766 {
4767 case svString :
4768 {
4769 svl::SharedString aStr = PopString();
4770 if ( mrDoc.GetTable(aStr.getString(), nVal))
4771 ++nVal;
4772 else
4773 SetError( FormulaError::IllegalArgument );
4774 }
4775 break;
4776 case svSingleRef :
4777 {
4778 SCCOL nCol1(0);
4779 SCROW nRow1(0);
4780 SCTAB nTab1(0);
4781 PopSingleRef(nCol1, nRow1, nTab1);
4782 nVal = nTab1 + 1;
4783 }
4784 break;
4785 case svDoubleRef :
4786 {
4787 SCCOL nCol1;
4788 SCROW nRow1;
4789 SCTAB nTab1;
4790 SCCOL nCol2;
4791 SCROW nRow2;
4792 SCTAB nTab2;
4793 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
4794 nVal = nTab1 + 1;
4795 }
4796 break;
4797 default:
4798 SetError( FormulaError::IllegalParameter );
4799 }
4800 if ( nGlobalError != FormulaError::NONE )
4801 nVal = 0;
4802 }
4803 PushDouble( static_cast<double>(nVal) );
4804 }
4805
4806 namespace {
4807
4808 class VectorMatrixAccessor
4809 {
4810 public:
4811 VectorMatrixAccessor(const ScMatrix& rMat, bool bColVec) :
4812 mrMat(rMat), mbColVec(bColVec) {}
4813
4814 bool IsEmpty(SCSIZE i) const
4815 {
4816 return mbColVec ? mrMat.IsEmpty(0, i) : mrMat.IsEmpty(i, 0);
4817 }
4818
4819 bool IsEmptyPath(SCSIZE i) const
4820 {
4821 return mbColVec ? mrMat.IsEmptyPath(0, i) : mrMat.IsEmptyPath(i, 0);
4822 }
4823
4824 bool IsValue(SCSIZE i) const
4825 {
4826 return mbColVec ? mrMat.IsValue(0, i) : mrMat.IsValue(i, 0);
4827 }
4828
4829 bool IsStringOrEmpty(SCSIZE i) const
4830 {
4831 return mbColVec ? mrMat.IsStringOrEmpty(0, i) : mrMat.IsStringOrEmpty(i, 0);
4832 }
4833
4834 double GetDouble(SCSIZE i) const
4835 {
4836 return mbColVec ? mrMat.GetDouble(0, i) : mrMat.GetDouble(i, 0);
4837 }
4838
4839 OUString GetString(SCSIZE i) const
4840 {
4841 return mbColVec ? mrMat.GetString(0, i).getString() : mrMat.GetString(i, 0).getString();
4842 }
4843
4844 SCSIZE GetElementCount() const
4845 {
4846 SCSIZE nC, nR;
4847 mrMat.GetDimensions(nC, nR);
4848 return mbColVec ? nR : nC;
4849 }
4850
4851 private:
4852 const ScMatrix& mrMat;
4853 bool mbColVec;
4854 };
4855
4856 /** returns -1 when the matrix value is smaller than the query value, 0 when
4857 they are equal, and 1 when the matrix value is larger than the query
4858 value. */
4859 sal_Int32 lcl_CompareMatrix2Query(
4860 SCSIZE i, const VectorMatrixAccessor& rMat, const ScQueryParam& rParam, const ScQueryEntry& rEntry, bool bMatchWholeCell )
4861 {
4862 if (rMat.IsEmpty(i))
4863 {
4864 /* TODO: in case we introduced query for real empty this would have to
4865 * be changed! */
4866 return -1; // empty always less than anything else
4867 }
4868
4869 /* FIXME: what is an empty path (result of IF(false;true_path) in
4870 * comparisons? */
4871
4872 bool bByString = rEntry.GetQueryItem().meType == ScQueryEntry::ByString;
4873 if (rMat.IsValue(i))
4874 {
4875 const double nVal1 = rMat.GetDouble(i);
4876 if (!std::isfinite(nVal1))
4877 {
4878 // XXX Querying for error values is not required, otherwise we'd
4879 // need to check here.
4880 return 1; // error always greater than numeric or string
4881 }
4882
4883 if (bByString)
4884 return -1; // numeric always less than string
4885
4886 const double nVal2 = rEntry.GetQueryItem().mfVal;
4887 // XXX Querying for error values is not required, otherwise we'd need
4888 // to check here and move that check before the bByString check.
4889 if (nVal1 == nVal2)
4890 return 0;
4891
4892 return nVal1 < nVal2 ? -1 : 1;
4893 }
4894
4895 if (!bByString)
4896 return 1; // string always greater than numeric
4897
4898 OUString aStr1 = rMat.GetString(i);
4899 OUString aStr2 = rEntry.GetQueryItem().maString.getString();
4900
4901 // bRealWildOrRegExp
4902 if (rParam.eSearchType != utl::SearchParam::SearchType::Normal &&
4903 ((rEntry.eOp == SC_EQUAL) || (rEntry.eOp == SC_NOT_EQUAL)))
4904 {
4905 sal_Int32 nStart = 0;
4906 sal_Int32 nEnd = aStr1.getLength();
4907
4908 bool bMatch = rEntry.GetSearchTextPtr(rParam.eSearchType, rParam.bCaseSens, bMatchWholeCell)
4909 ->SearchForward(aStr1, &nStart, &nEnd);
4910 // from 614 on, nEnd is behind the found text
4911 if (bMatch && bMatchWholeCell
4912 && (nStart != 0 || nEnd != aStr1.getLength()))
4913 bMatch = false; // RegExp must match entire cell string
4914
4915 bool bOk = ((rEntry.eOp == SC_NOT_EQUAL) ? !bMatch : bMatch);
4916
4917 if (bOk)
4918 return 0; // we have a WildOrRegExp match
4919 }
4920
4921 CollatorWrapper& rCollator = ScGlobal::GetCollator(rParam.bCaseSens);
4922 return rCollator.compareString(aStr1, aStr2);
4923 }
4924
4925 /** returns -1 when matrix(i) value is smaller than matrix(j) value, 0 when
4926 they are equal, and 1 when larger */
4927 sal_Int32 lcl_Compare2MatrixCells( SCSIZE i, const VectorMatrixAccessor& rMat, SCSIZE j )
4928 {
4929 // empty always less than anything else
4930 if (rMat.IsEmpty(i))
4931 return ( rMat.IsEmpty(j) ? 0 : -1 );
4932 else if (rMat.IsEmpty(j))
4933 return 1;
4934
4935 bool bByString = rMat.IsStringOrEmpty(j); // string, empty has already been handled
4936 if (rMat.IsValue(i))
4937 {
4938 const double nVal1 = rMat.GetDouble(i);
4939 if (!std::isfinite(nVal1))
4940 return 1; // error always greater than numeric or string
4941
4942 if (bByString)
4943 return -1; // numeric always less than string
4944
4945 const double nVal2 = rMat.GetDouble(j);
4946 if (nVal1 == nVal2)
4947 return 0;
4948
4949 return ( nVal1 < nVal2 ? -1 : 1 );
4950 }
4951
4952 if (!bByString)
4953 return 1; // string always greater than numeric
4954
4955 return ScGlobal::GetCollator().compareString(rMat.GetString(i), rMat.GetString(j)); // case-insensitive
4956 }
4957
4958 /** returns the last item with the identical value as the original item
4959 value. */
4960 void lcl_GetLastMatch( SCSIZE& rIndex, const VectorMatrixAccessor& rMat,
4961 SCSIZE nMatCount)
4962 {
4963 if (rMat.IsValue(rIndex))
4964 {
4965 double nVal = rMat.GetDouble(rIndex);
4966 while (rIndex < nMatCount-1 && rMat.IsValue(rIndex+1) &&
4967 nVal == rMat.GetDouble(rIndex+1))
4968 ++rIndex;
4969 }
4970 // Order of IsEmptyPath, IsEmpty, IsStringOrEmpty is significant!
4971 else if (rMat.IsEmptyPath(rIndex))
4972 {
4973 while (rIndex < nMatCount-1 && rMat.IsEmptyPath(rIndex+1))
4974 ++rIndex;
4975 }
4976 else if (rMat.IsEmpty(rIndex))
4977 {
4978 while (rIndex < nMatCount-1 && rMat.IsEmpty(rIndex+1))
4979 ++rIndex;
4980 }
4981 else if (rMat.IsStringOrEmpty(rIndex))
4982 {
4983 OUString aStr( rMat.GetString(rIndex));
4984 while (rIndex < nMatCount-1 && rMat.IsStringOrEmpty(rIndex+1) &&
4985 aStr == rMat.GetString(rIndex+1))
4986 ++rIndex;
4987 }
4988 else
4989 {
4990 OSL_FAIL("lcl_GetLastMatch: unhandled matrix type");
4991 }
4992 }
4993
4994 }
4995
4996 void ScInterpreter::ScMatch()
4997 {
4998 sal_uInt8 nParamCount = GetByte();
4999 if ( !MustHaveParamCount( nParamCount, 2, 3 ) )
5000 return;
5001
5002 VectorSearchArguments vsa;
5003 vsa.nSearchOpCode = SC_OPCODE_MATCH;
5004
5005 // get match mode
5006 double fType = ( nParamCount == 3 ? GetDouble() : 1.0 );
5007 switch ( static_cast<int>(fType) )
5008 {
5009 case -1 :
5010 vsa.eMatchMode = exactorG;
5011 vsa.eSearchMode = searchbdesc;
5012 break;
5013 case 0 :
5014 vsa.eMatchMode = exactorNA;
5015 vsa.eSearchMode = searchfwd;
5016 break;
5017 case 1 :
5018 // default value
5019 vsa.eMatchMode = exactorS;
5020 vsa.eSearchMode = searchbasc;
5021 break;
5022 default :
5023 PushIllegalParameter();
5024 return;
5025 }
5026
5027 // get vector to be searched
5028 switch (GetStackType())
5029 {
5030 case svSingleRef:
5031 PopSingleRef( vsa.nCol1, vsa.nRow1, vsa.nTab1);
5032 vsa.nCol2 = vsa.nCol1;
5033 vsa.nRow2 = vsa.nRow1;
5034 vsa.pMatSrc = nullptr;
5035 break;
5036 case svDoubleRef:
5037 {
5038 vsa.pMatSrc = nullptr;
5039 SCTAB nTab2 = 0;
5040 PopDoubleRef(vsa.nCol1, vsa.nRow1, vsa.nTab1, vsa.nCol2, vsa.nRow2, nTab2);
5041 if (vsa.nTab1 != nTab2 || (vsa.nCol1 != vsa.nCol2 && vsa.nRow1 != vsa.nRow2))
5042 {
5043 PushIllegalParameter();
5044 return;
5045 }
5046 }
5047 break;
5048 case svMatrix:
5049 case svExternalDoubleRef:
5050 {
5051 if (GetStackType() == svMatrix)
5052 vsa.pMatSrc = PopMatrix();
5053 else
5054 PopExternalDoubleRef(vsa.pMatSrc);
5055
5056 if (!vsa.pMatSrc)
5057 {
5058 PushIllegalParameter();
5059 return;
5060 }
5061 }
5062 break;
5063 default:
5064 PushIllegalParameter();
5065 return;
5066 }
5067
5068 // get search value
5069 if (nGlobalError == FormulaError::NONE)
5070 {
5071 switch ( GetStackType() )
5072 {
5073 case svDouble:
5074 {
5075 vsa.isStringSearch = false;
5076 vsa.fSearchVal = GetDouble();
5077 }
5078 break;
5079 case svString:
5080 {
5081 vsa.isStringSearch = true;
5082 vsa.sSearchStr = GetString();
5083 }
5084 break;
5085 case svDoubleRef :
5086 case svSingleRef :
5087 {
5088 ScAddress aAdr;
5089 if ( !PopDoubleRefOrSingleRef( aAdr ) )
5090 {
5091 PushInt(0);
5092 return ;
5093 }
5094 ScRefCellValue aCell(mrDoc, aAdr);
5095 if (aCell.hasNumeric())
5096 {
5097 vsa.isStringSearch = false;
5098 vsa.fSearchVal = GetCellValue(aAdr, aCell);
5099 }
5100 else
5101 {
5102 vsa.isStringSearch = true;
5103 GetCellString(vsa.sSearchStr, aCell);
5104 }
5105 }
5106 break;
5107 case svExternalSingleRef:
5108 {
5109 ScExternalRefCache::TokenRef pToken;
5110 PopExternalSingleRef(pToken);
5111 if (nGlobalError != FormulaError::NONE)
5112 {
5113 PushError( nGlobalError);
5114 return;
5115 }
5116 if (pToken->GetType() == svDouble)
5117 {
5118 vsa.isStringSearch = false;
5119 vsa.fSearchVal = pToken->GetDouble();
5120 }
5121 else
5122 {
5123 vsa.isStringSearch = true;
5124 vsa.sSearchStr = pToken->GetString();
5125 }
5126 }
5127 break;
5128 case svExternalDoubleRef:
5129 case svMatrix :
5130 {
5131 ScMatValType nType = GetDoubleOrStringFromMatrix(
5132 vsa.fSearchVal, vsa.sSearchStr);
5133 vsa.isStringSearch = ScMatrix::IsNonValueType(nType);
5134 }
5135 break;
5136 default:
5137 {
5138 PushIllegalParameter();
5139 return;
5140 }
5141 }
5142
5143 // execute search
5144 if ( SearchVectorForValue( vsa ) )
5145 PushDouble( vsa.nIndex );
5146 else
5147 {
5148 if ( vsa.isResultNA )
5149 PushNA();
5150 else
5151 return; // error occurred and has already been pushed
5152 }
5153 }
5154 else
5155 PushIllegalParameter();
5156 }
5157
5158 void ScInterpreter::ScXMatch()
5159 {
5160 sal_uInt8 nParamCount = GetByte();
5161 if (!MustHaveParamCount(nParamCount, 2, 4))
5162 return;
5163
5164 VectorSearchArguments vsa;
5165 vsa.nSearchOpCode = SC_OPCODE_X_MATCH;
5166
5167 // get search mode
5168 if (nParamCount == 4)
5169 {
5170 sal_Int16 k = GetInt16();
5171 if (k >= -2 && k <= 2 && k != 0)
5172 vsa.eSearchMode = static_cast<SearchMode>(k);
5173 else
5174 {
5175 PushIllegalParameter();
5176 return;
5177 }
5178 }
5179 else
5180 vsa.eSearchMode = searchfwd;
5181
5182 // get match mode
5183 if (nParamCount >= 3)
5184 {
5185 sal_Int16 k = GetInt16();
5186 if (k >= -1 && k <= 3)
5187 vsa.eMatchMode = static_cast<MatchMode>(k);
5188 else
5189 {
5190 PushIllegalParameter();
5191 return;
5192 }
5193 }
5194 else
5195 vsa.eMatchMode = exactorNA;
5196
5197 // get vector to be searched
5198 switch (GetStackType())
5199 {
5200 case svSingleRef:
5201 {
5202 PopSingleRef(vsa.nCol1, vsa.nRow1, vsa.nTab1);
5203 vsa.nCol2 = vsa.nCol1;
5204 vsa.nRow2 = vsa.nRow1;
5205 vsa.pMatSrc = nullptr;
5206 }
5207 break;
5208 case svDoubleRef:
5209 {
5210 vsa.pMatSrc = nullptr;
5211 SCTAB nTab2 = 0;
5212 PopDoubleRef(vsa.nCol1, vsa.nRow1, vsa.nTab1, vsa.nCol2, vsa.nRow2, nTab2);
5213 if (vsa.nTab1 != nTab2 || (vsa.nCol1 != vsa.nCol2 && vsa.nRow1 != vsa.nRow2))
5214 {
5215 PushIllegalParameter();
5216 return;
5217 }
5218 }
5219 break;
5220 case svMatrix:
5221 case svExternalDoubleRef:
5222 {
5223 if (GetStackType() == svMatrix)
5224 vsa.pMatSrc = PopMatrix();
5225 else
5226 PopExternalDoubleRef(vsa.pMatSrc);
5227
5228 if (!vsa.pMatSrc)
5229 {
5230 PushIllegalParameter();
5231 return;
5232 }
5233 }
5234 break;
5235 default:
5236 PushIllegalParameter();
5237 return;
5238 }
5239
5240 // get search value
5241 if (nGlobalError == FormulaError::NONE)
5242 {
5243 switch (GetRawStackType())
5244 {
5245 case svMissing:
5246 case svEmptyCell:
5247 {
5248 vsa.isEmptySearch = true;
5249 vsa.isStringSearch = false;
5250 vsa.sSearchStr = GetString();
5251 }
5252 break;
5253 case svDouble:
5254 {
5255 vsa.isStringSearch = false;
5256 vsa.fSearchVal = GetDouble();
5257 }
5258 break;
5259 case svString:
5260 {
5261 vsa.isStringSearch = true;
5262 vsa.sSearchStr = GetString();
5263 }
5264 break;
5265 case svDoubleRef:
5266 case svSingleRef:
5267 {
5268 ScAddress aAdr;
5269 if (!PopDoubleRefOrSingleRef(aAdr))
5270 {
5271 PushInt(0);
5272 return;
5273 }
5274 ScRefCellValue aCell(mrDoc, aAdr);
5275 if (aCell.hasNumeric())
5276 {
5277 vsa.isStringSearch = false;
5278 vsa.fSearchVal = GetCellValue(aAdr, aCell);
5279 }
5280 else
5281 {
5282 vsa.isStringSearch = true;
5283 GetCellString(vsa.sSearchStr, aCell);
5284 }
5285 }
5286 break;
5287 case svExternalSingleRef:
5288 {
5289 ScExternalRefCache::TokenRef pToken;
5290 PopExternalSingleRef(pToken);
5291 if (nGlobalError != FormulaError::NONE)
5292 {
5293 PushError(nGlobalError);
5294 return;
5295 }
5296 if (pToken->GetType() == svDouble)
5297 {
5298 vsa.isStringSearch = false;
5299 vsa.fSearchVal = pToken->GetDouble();
5300 }
5301 else
5302 {
5303 vsa.isStringSearch = true;
5304 vsa.sSearchStr = pToken->GetString();
5305 }
5306 }
5307 break;
5308 case svExternalDoubleRef:
5309 case svMatrix:
5310 {
5311 ScMatValType nType = GetDoubleOrStringFromMatrix(
5312 vsa.fSearchVal, vsa.sSearchStr);
5313 vsa.isStringSearch = ScMatrix::IsNonValueType(nType);
5314 }
5315 break;
5316 default:
5317 {
5318 PushIllegalParameter();
5319 return;
5320 }
5321 }
5322
5323 // execute search
5324 if (SearchVectorForValue(vsa))
5325 PushDouble(vsa.nIndex);
5326 else
5327 {
5328 if (vsa.isResultNA)
5329 PushNA();
5330 else
5331 return; // error occurred and has already been pushed
5332 }
5333 }
5334 else
5335 PushIllegalParameter();
5336 }
5337
5338 namespace {
5339
5340 bool isCellContentEmpty( const ScRefCellValue& rCell )
5341 {
5342 switch (rCell.getType())
5343 {
5344 case CELLTYPE_VALUE:
5345 case CELLTYPE_STRING:
5346 case CELLTYPE_EDIT:
5347 return false;
5348 case CELLTYPE_FORMULA:
5349 {
5350 // NOTE: Excel treats ="" in a referenced cell as blank in
5351 // COUNTBLANK() but not in ISBLANK(), which is inconsistent.
5352 // COUNTBLANK() tests the (display) result whereas ISBLANK() tests
5353 // the cell content.
5354 // ODFF allows both for COUNTBLANK().
5355 // OOo and LibreOffice prior to 4.4 did not treat ="" as blank in
5356 // COUNTBLANK(), we now do for Excel interoperability.
5357 /* TODO: introduce yet another compatibility option? */
5358 sc::FormulaResultValue aRes = rCell.getFormula()->GetResult();
5359 if (aRes.meType != sc::FormulaResultValue::String)
5360 return false;
5361 if (!aRes.maString.isEmpty())
5362 return false;
5363 }
5364 break;
5365 default:
5366 ;
5367 }
5368
5369 return true;
5370 }
5371
5372 }
5373
5374 void ScInterpreter::ScCountEmptyCells()
5375 {
5376 if ( !MustHaveParamCount( GetByte(), 1 ) )
5377 return;
5378
5379 const SCSIZE nMatRows = GetRefListArrayMaxSize(1);
5380 // There's either one RefList and nothing else, or none.
5381 ScMatrixRef xResMat = (nMatRows ? GetNewMat( 1, nMatRows, /*bEmpty*/true ) : nullptr);
5382 sal_uLong nMaxCount = 0, nCount = 0;
5383 switch (GetStackType())
5384 {
5385 case svSingleRef :
5386 {
5387 nMaxCount = 1;
5388 ScAddress aAdr;
5389 PopSingleRef( aAdr );
5390 ScRefCellValue aCell(mrDoc, aAdr);
5391 if (!isCellContentEmpty(aCell))
5392 nCount = 1;
5393 }
5394 break;
5395 case svRefList :
5396 case svDoubleRef :
5397 {
5398 ScRange aRange;
5399 short nParam = 1;
5400 SCSIZE nRefListArrayPos = 0;
5401 size_t nRefInList = 0;
5402 while (nParam-- > 0)
5403 {
5404 nRefListArrayPos = nRefInList;
5405 PopDoubleRef( aRange, nParam, nRefInList);
5406 nMaxCount +=
5407 static_cast<sal_uLong>(aRange.aEnd.Row() - aRange.aStart.Row() + 1) *
5408 static_cast<sal_uLong>(aRange.aEnd.Col() - aRange.aStart.Col() + 1) *
5409 static_cast<sal_uLong>(aRange.aEnd.Tab() - aRange.aStart.Tab() + 1);
5410
5411 ScCellIterator aIter( mrDoc, aRange, mnSubTotalFlags);
5412 for (bool bHas = aIter.first(); bHas; bHas = aIter.next())
5413 {
5414 const ScRefCellValue& rCell = aIter.getRefCellValue();
5415 if (!isCellContentEmpty(rCell))
5416 ++nCount;
5417 }
5418 if (xResMat)
5419 {
5420 xResMat->PutDouble( nMaxCount - nCount, 0, nRefListArrayPos);
5421 nMaxCount = nCount = 0;
5422 }
5423 }
5424 }
5425 break;
5426 case svMatrix:
5427 case svExternalSingleRef:
5428 case svExternalDoubleRef:
5429 {
5430 ScMatrixRef xMat = GetMatrix();
5431 if (!xMat)
5432 SetError( FormulaError::IllegalParameter);
5433 else
5434 {
5435 SCSIZE nC, nR;
5436 xMat->GetDimensions( nC, nR);
5437 nMaxCount = nC * nR;
5438 // Numbers (implicit), strings and error values, ignore empty
5439 // strings as those if not entered in an inline array are the
5440 // result of a formula, to be par with a reference to formula
5441 // cell as *visual* blank, see isCellContentEmpty() above.
5442 nCount = xMat->Count( true, true, true);
5443 }
5444 }
5445 break;
5446 default : SetError(FormulaError::IllegalParameter); break;
5447 }
5448 if (xResMat)
5449 PushMatrix( xResMat);
5450 else
5451 PushDouble(nMaxCount - nCount);
5452 }
5453
5454 void ScInterpreter::IterateParametersIf( ScIterFuncIf eFunc )
5455 {
5456 sal_uInt8 nParamCount = GetByte();
5457 if ( !MustHaveParamCount( nParamCount, 2, 3 ) )
5458 return;
5459
5460 SCCOL nCol3 = 0;
5461 SCROW nRow3 = 0;
5462 SCTAB nTab3 = 0;
5463
5464 ScMatrixRef pSumExtraMatrix;
5465 bool bSumExtraRange = (nParamCount == 3);
5466 if (bSumExtraRange)
5467 {
5468 // Save only the upperleft cell in case of cell range. The geometry
5469 // of the 3rd parameter is taken from the 1st parameter.
5470
5471 switch ( GetStackType() )
5472 {
5473 case svDoubleRef :
5474 {
5475 SCCOL nColJunk = 0;
5476 SCROW nRowJunk = 0;
5477 SCTAB nTabJunk = 0;
5478 PopDoubleRef( nCol3, nRow3, nTab3, nColJunk, nRowJunk, nTabJunk );
5479 if ( nTabJunk != nTab3 )
5480 {
5481 PushError( FormulaError::IllegalParameter);
5482 return;
5483 }
5484 }
5485 break;
5486 case svSingleRef :
5487 PopSingleRef( nCol3, nRow3, nTab3 );
5488 break;
5489 case svMatrix:
5490 pSumExtraMatrix = PopMatrix();
5491 // nCol3, nRow3, nTab3 remain 0
5492 break;
5493 case svExternalSingleRef:
5494 {
5495 pSumExtraMatrix = GetNewMat(1,1);
5496 ScExternalRefCache::TokenRef pToken;
5497 PopExternalSingleRef(pToken);
5498 if (nGlobalError != FormulaError::NONE)
5499 {
5500 PushError( nGlobalError);
5501 return;
5502 }
5503
5504 if (pToken->GetType() == svDouble)
5505 pSumExtraMatrix->PutDouble(pToken->GetDouble(), 0, 0);
5506 else
5507 pSumExtraMatrix->PutString(pToken->GetString(), 0, 0);
5508 }
5509 break;
5510 case svExternalDoubleRef:
5511 PopExternalDoubleRef(pSumExtraMatrix);
5512 break;
5513 default:
5514 PushError( FormulaError::IllegalParameter);
5515 return;
5516 }
5517 }
5518
5519 svl::SharedString aString;
5520 double fVal = 0.0;
5521 bool bIsString = true;
5522 switch ( GetStackType() )
5523 {
5524 case svDoubleRef :
5525 case svSingleRef :
5526 {
5527 ScAddress aAdr;
5528 if ( !PopDoubleRefOrSingleRef( aAdr ) )
5529 {
5530 PushError( nGlobalError);
5531 return;
5532 }
5533
5534 ScRefCellValue aCell(mrDoc, aAdr);
5535 switch (aCell.getType())
5536 {
5537 case CELLTYPE_VALUE :
5538 fVal = GetCellValue(aAdr, aCell);
5539 bIsString = false;
5540 break;
5541 case CELLTYPE_FORMULA :
5542 if (aCell.getFormula()->IsValue())
5543 {
5544 fVal = GetCellValue(aAdr, aCell);
5545 bIsString = false;
5546 }
5547 else
5548 GetCellString(aString, aCell);
5549 break;
5550 case CELLTYPE_STRING :
5551 case CELLTYPE_EDIT :
5552 GetCellString(aString, aCell);
5553 break;
5554 default:
5555 fVal = 0.0;
5556 bIsString = false;
5557 }
5558 }
5559 break;
5560 case svString:
5561 aString = GetString();
5562 break;
5563 case svMatrix :
5564 case svExternalDoubleRef:
5565 {
5566 ScMatValType nType = GetDoubleOrStringFromMatrix( fVal, aString);
5567 bIsString = ScMatrix::IsRealStringType( nType);
5568 }
5569 break;
5570 case svExternalSingleRef:
5571 {
5572 ScExternalRefCache::TokenRef pToken;
5573 PopExternalSingleRef(pToken);
5574 if (nGlobalError == FormulaError::NONE)
5575 {
5576 if (pToken->GetType() == svDouble)
5577 {
5578 fVal = pToken->GetDouble();
5579 bIsString = false;
5580 }
5581 else
5582 aString = pToken->GetString();
5583 }
5584 }
5585 break;
5586 default:
5587 {
5588 fVal = GetDouble();
5589 bIsString = false;
5590 }
5591 }
5592
5593 KahanSum fSum = 0.0;
5594 double fRes = 0.0;
5595 double fCount = 0.0;
5596 short nParam = 1;
5597 const SCSIZE nMatRows = GetRefListArrayMaxSize( nParam);
5598 // There's either one RefList and nothing else, or none.
5599 ScMatrixRef xResMat = (nMatRows ? GetNewMat( 1, nMatRows, /*bEmpty*/true ) : nullptr);
5600 SCSIZE nRefListArrayPos = 0;
5601 size_t nRefInList = 0;
5602 while (nParam-- > 0)
5603 {
5604 SCCOL nCol1 = 0;
5605 SCROW nRow1 = 0;
5606 SCTAB nTab1 = 0;
5607 SCCOL nCol2 = 0;
5608 SCROW nRow2 = 0;
5609 SCTAB nTab2 = 0;
5610 ScMatrixRef pQueryMatrix;
5611 switch ( GetStackType() )
5612 {
5613 case svRefList :
5614 if (bSumExtraRange)
5615 {
5616 /* TODO: this could resolve if all refs are of the same size */
5617 SetError( FormulaError::IllegalParameter);
5618 }
5619 else
5620 {
5621 nRefListArrayPos = nRefInList;
5622 ScRange aRange;
5623 PopDoubleRef( aRange, nParam, nRefInList);
5624 aRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
5625 }
5626 break;
5627 case svDoubleRef :
5628 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
5629 break;
5630 case svSingleRef :
5631 PopSingleRef( nCol1, nRow1, nTab1 );
5632 nCol2 = nCol1;
5633 nRow2 = nRow1;
5634 nTab2 = nTab1;
5635 break;
5636 case svMatrix:
5637 case svExternalSingleRef:
5638 case svExternalDoubleRef:
5639 {
5640 pQueryMatrix = GetMatrix();
5641 if (!pQueryMatrix)
5642 {
5643 PushError( FormulaError::IllegalParameter);
5644 return;
5645 }
5646 nCol1 = 0;
5647 nRow1 = 0;
5648 nTab1 = 0;
5649 SCSIZE nC, nR;
5650 pQueryMatrix->GetDimensions( nC, nR);
5651 nCol2 = static_cast<SCCOL>(nC - 1);
5652 nRow2 = static_cast<SCROW>(nR - 1);
5653 nTab2 = 0;
5654 }
5655 break;
5656 default:
5657 SetError( FormulaError::IllegalParameter);
5658 }
5659 if ( nTab1 != nTab2 )
5660 {
5661 SetError( FormulaError::IllegalParameter);
5662 }
5663
5664 if (bSumExtraRange)
5665 {
5666 // Take the range geometry of the 1st parameter and apply it to
5667 // the 3rd. If parts of the resulting range would point outside
5668 // the sheet, don't complain but silently ignore and simply cut
5669 // them away, this is what Xcl does :-/
5670
5671 // For the cut-away part we also don't need to determine the
5672 // criteria match, so shrink the source range accordingly,
5673 // instead of the result range.
5674 SCCOL nColDelta = nCol2 - nCol1;
5675 SCROW nRowDelta = nRow2 - nRow1;
5676 SCCOL nMaxCol;
5677 SCROW nMaxRow;
5678 if (pSumExtraMatrix)
5679 {
5680 SCSIZE nC, nR;
5681 pSumExtraMatrix->GetDimensions( nC, nR);
5682 nMaxCol = static_cast<SCCOL>(nC - 1);
5683 nMaxRow = static_cast<SCROW>(nR - 1);
5684 }
5685 else
5686 {
5687 nMaxCol = mrDoc.MaxCol();
5688 nMaxRow = mrDoc.MaxRow();
5689 }
5690 if (nCol3 + nColDelta > nMaxCol)
5691 {
5692 SCCOL nNewDelta = nMaxCol - nCol3;
5693 nCol2 = nCol1 + nNewDelta;
5694 }
5695
5696 if (nRow3 + nRowDelta > nMaxRow)
5697 {
5698 SCROW nNewDelta = nMaxRow - nRow3;
5699 nRow2 = nRow1 + nNewDelta;
5700 }
5701 }
5702 else
5703 {
5704 nCol3 = nCol1;
5705 nRow3 = nRow1;
5706 nTab3 = nTab1;
5707 }
5708
5709 if (nGlobalError == FormulaError::NONE)
5710 {
5711 ScQueryParam rParam;
5712 rParam.nRow1 = nRow1;
5713 rParam.nRow2 = nRow2;
5714
5715 ScQueryEntry& rEntry = rParam.GetEntry(0);
5716 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
5717 rEntry.bDoQuery = true;
5718 if (!bIsString)
5719 {
5720 rItem.meType = ScQueryEntry::ByValue;
5721 rItem.mfVal = fVal;
5722 rEntry.eOp = SC_EQUAL;
5723 }
5724 else
5725 {
5726 rParam.FillInExcelSyntax(mrDoc.GetSharedStringPool(), aString.getString(), 0, &mrContext);
5727 if (rItem.meType == ScQueryEntry::ByString)
5728 rParam.eSearchType = DetectSearchType(rItem.maString.getString(), mrDoc);
5729 }
5730 ScAddress aAdr;
5731 aAdr.SetTab( nTab3 );
5732 rParam.nCol1 = nCol1;
5733 rParam.nCol2 = nCol2;
5734 rEntry.nField = nCol1;
5735 SCCOL nColDiff = nCol3 - nCol1;
5736 SCROW nRowDiff = nRow3 - nRow1;
5737 if (pQueryMatrix)
5738 {
5739 // Never case-sensitive.
5740 sc::CompareOptions aOptions( mrDoc, rEntry, rParam.eSearchType);
5741 ScMatrixRef pResultMatrix = QueryMat( pQueryMatrix, aOptions);
5742 if (nGlobalError != FormulaError::NONE || !pResultMatrix)
5743 {
5744 PushIllegalParameter();
5745 return;
5746 }
5747
5748 if (pSumExtraMatrix)
5749 {
5750 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
5751 {
5752 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
5753 {
5754 if (pResultMatrix->IsValue( nCol, nRow) &&
5755 pResultMatrix->GetDouble( nCol, nRow))
5756 {
5757 SCSIZE nC = nCol + nColDiff;
5758 SCSIZE nR = nRow + nRowDiff;
5759 if (pSumExtraMatrix->IsValue( nC, nR))
5760 {
5761 fVal = pSumExtraMatrix->GetDouble( nC, nR);
5762 ++fCount;
5763 fSum += fVal;
5764 }
5765 }
5766 }
5767 }
5768 }
5769 else if (!bSumExtraRange)
5770 {
5771 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
5772 {
5773 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
5774 {
5775 if (pResultMatrix->IsValue( nCol, nRow) &&
5776 pResultMatrix->GetDouble( nCol, nRow))
5777 {
5778 if (pQueryMatrix->IsValue( nCol, nRow))
5779 {
5780 fVal = pQueryMatrix->GetDouble( nCol, nRow);
5781 ++fCount;
5782 fSum += fVal;
5783 }
5784 }
5785 }
5786 }
5787 }
5788 else
5789 {
5790 for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
5791 {
5792 for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
5793 {
5794 if (pResultMatrix->GetDouble( nCol, nRow))
5795 {
5796 aAdr.SetCol( nCol + nColDiff);
5797 aAdr.SetRow( nRow + nRowDiff);
5798 ScRefCellValue aCell(mrDoc, aAdr);
5799 if (aCell.hasNumeric())
5800 {
5801 fVal = GetCellValue(aAdr, aCell);
5802 ++fCount;
5803 fSum += fVal;
5804 }
5805 }
5806 }
5807 }
5808 }
5809 }
5810 else
5811 {
5812 ScQueryCellIteratorDirect aCellIter(mrDoc, mrContext, nTab1, rParam, false, false);
5813 // Increment Entry.nField in iterator when switching to next column.
5814 aCellIter.SetAdvanceQueryParamEntryField( true );
5815 if ( aCellIter.GetFirst() )
5816 {
5817 if (pSumExtraMatrix)
5818 {
5819 do
5820 {
5821 SCSIZE nC = aCellIter.GetCol() + nColDiff;
5822 SCSIZE nR = aCellIter.GetRow() + nRowDiff;
5823 if (pSumExtraMatrix->IsValue( nC, nR))
5824 {
5825 fVal = pSumExtraMatrix->GetDouble( nC, nR);
5826 ++fCount;
5827 fSum += fVal;
5828 }
5829 } while ( aCellIter.GetNext() );
5830 }
5831 else
5832 {
5833 do
5834 {
5835 aAdr.SetCol( aCellIter.GetCol() + nColDiff);
5836 aAdr.SetRow( aCellIter.GetRow() + nRowDiff);
5837 ScRefCellValue aCell(mrDoc, aAdr);
5838 if (aCell.hasNumeric())
5839 {
5840 fVal = GetCellValue(aAdr, aCell);
5841 ++fCount;
5842 fSum += fVal;
5843 }
5844 } while ( aCellIter.GetNext() );
5845 }
5846 }
5847 }
5848 }
5849 else
5850 {
5851 PushError( FormulaError::IllegalParameter);
5852 return;
5853 }
5854
5855 switch( eFunc )
5856 {
5857 case ifSUMIF: fRes = fSum.get(); break;
5858 case ifAVERAGEIF: fRes = div( fSum.get(), fCount ); break;
5859 }
5860 if (xResMat)
5861 {
5862 if (nGlobalError == FormulaError::NONE)
5863 xResMat->PutDouble( fRes, 0, nRefListArrayPos);
5864 else
5865 {
5866 xResMat->PutError( nGlobalError, 0, nRefListArrayPos);
5867 nGlobalError = FormulaError::NONE;
5868 }
5869 fRes = fCount = 0.0;
5870 fSum = 0;
5871 }
5872 }
5873 if (xResMat)
5874 PushMatrix( xResMat);
5875 else
5876 PushDouble( fRes);
5877 }
5878
5879 void ScInterpreter::ScSumIf()
5880 {
5881 IterateParametersIf( ifSUMIF);
5882 }
5883
5884 void ScInterpreter::ScAverageIf()
5885 {
5886 IterateParametersIf( ifAVERAGEIF);
5887 }
5888
5889 void ScInterpreter::ScCountIf()
5890 {
5891 if ( !MustHaveParamCount( GetByte(), 2 ) )
5892 return;
5893
5894 svl::SharedString aString;
5895 double fVal = 0.0;
5896 bool bIsString = true;
5897 switch ( GetStackType() )
5898 {
5899 case svDoubleRef :
5900 case svSingleRef :
5901 {
5902 ScAddress aAdr;
5903 if ( !PopDoubleRefOrSingleRef( aAdr ) )
5904 {
5905 PushInt(0);
5906 return ;
5907 }
5908 ScRefCellValue aCell(mrDoc, aAdr);
5909 switch (aCell.getType())
5910 {
5911 case CELLTYPE_VALUE :
5912 fVal = GetCellValue(aAdr, aCell);
5913 bIsString = false;
5914 break;
5915 case CELLTYPE_FORMULA :
5916 if (aCell.getFormula()->IsValue())
5917 {
5918 fVal = GetCellValue(aAdr, aCell);
5919 bIsString = false;
5920 }
5921 else
5922 GetCellString(aString, aCell);
5923 break;
5924 case CELLTYPE_STRING :
5925 case CELLTYPE_EDIT :
5926 GetCellString(aString, aCell);
5927 break;
5928 default:
5929 fVal = 0.0;
5930 bIsString = false;
5931 }
5932 }
5933 break;
5934 case svMatrix:
5935 case svExternalSingleRef:
5936 case svExternalDoubleRef:
5937 {
5938 ScMatValType nType = GetDoubleOrStringFromMatrix(fVal, aString);
5939 bIsString = ScMatrix::IsRealStringType( nType);
5940 }
5941 break;
5942 case svString:
5943 aString = GetString();
5944 break;
5945 default:
5946 {
5947 fVal = GetDouble();
5948 bIsString = false;
5949 }
5950 }
5951 double fCount = 0.0;
5952 short nParam = 1;
5953 const SCSIZE nMatRows = GetRefListArrayMaxSize( nParam);
5954 // There's either one RefList and nothing else, or none.
5955 ScMatrixRef xResMat = (nMatRows ? GetNewMat( 1, nMatRows, /*bEmpty*/true ) : nullptr);
5956 SCSIZE nRefListArrayPos = 0;
5957 size_t nRefInList = 0;
5958 while (nParam-- > 0)
5959 {
5960 SCCOL nCol1 = 0;
5961 SCROW nRow1 = 0;
5962 SCTAB nTab1 = 0;
5963 SCCOL nCol2 = 0;
5964 SCROW nRow2 = 0;
5965 SCTAB nTab2 = 0;
5966 ScMatrixRef pQueryMatrix;
5967 const ScComplexRefData* refData = nullptr;
5968 switch ( GetStackType() )
5969 {
5970 case svRefList :
5971 nRefListArrayPos = nRefInList;
5972 [[fallthrough]];
5973 case svDoubleRef :
5974 {
5975 refData = GetStackDoubleRef(nRefInList);
5976 ScRange aRange;
5977 PopDoubleRef( aRange, nParam, nRefInList);
5978 aRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
5979 }
5980 break;
5981 case svSingleRef :
5982 PopSingleRef( nCol1, nRow1, nTab1 );
5983 nCol2 = nCol1;
5984 nRow2 = nRow1;
5985 nTab2 = nTab1;
5986 break;
5987 case svMatrix:
5988 case svExternalSingleRef:
5989 case svExternalDoubleRef:
5990 {
5991 pQueryMatrix = GetMatrix();
5992 if (!pQueryMatrix)
5993 {
5994 PushIllegalParameter();
5995 return;
5996 }
5997 nCol1 = 0;
5998 nRow1 = 0;
5999 nTab1 = 0;
6000 SCSIZE nC, nR;
6001 pQueryMatrix->GetDimensions( nC, nR);
6002 nCol2 = static_cast<SCCOL>(nC - 1);
6003 nRow2 = static_cast<SCROW>(nR - 1);
6004 nTab2 = 0;
6005 }
6006 break;
6007 default:
6008 PopError(); // Propagate it further
6009 PushIllegalParameter();
6010 return ;
6011 }
6012 if ( nTab1 != nTab2 )
6013 {
6014 PushIllegalParameter();
6015 return;
6016 }
6017 if (nCol1 > nCol2)
6018 {
6019 PushIllegalParameter();
6020 return;
6021 }
6022 if (nGlobalError == FormulaError::NONE)
6023 {
6024 ScQueryParam rParam;
6025 rParam.nRow1 = nRow1;
6026 rParam.nRow2 = nRow2;
6027 rParam.nTab = nTab1;
6028
6029 ScQueryEntry& rEntry = rParam.GetEntry(0);
6030 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
6031 rEntry.bDoQuery = true;
6032 if (!bIsString)
6033 {
6034 rItem.meType = ScQueryEntry::ByValue;
6035 rItem.mfVal = fVal;
6036 rEntry.eOp = SC_EQUAL;
6037 }
6038 else
6039 {
6040 rParam.FillInExcelSyntax(mrDoc.GetSharedStringPool(), aString.getString(), 0, &mrContext);
6041 if (rItem.meType == ScQueryEntry::ByString)
6042 rParam.eSearchType = DetectSearchType(rItem.maString.getString(), mrDoc);
6043 }
6044 rParam.nCol1 = nCol1;
6045 rParam.nCol2 = nCol2;
6046 rEntry.nField = nCol1;
6047 if (pQueryMatrix)
6048 {
6049 // Never case-sensitive.
6050 sc::CompareOptions aOptions( mrDoc, rEntry, rParam.eSearchType);
6051 ScMatrixRef pResultMatrix = QueryMat( pQueryMatrix, aOptions);
6052 if (nGlobalError != FormulaError::NONE || !pResultMatrix)
6053 {
6054 PushIllegalParameter();
6055 return;
6056 }
6057
6058 SCSIZE nSize = pResultMatrix->GetElementCount();
6059 for (SCSIZE nIndex = 0; nIndex < nSize; ++nIndex)
6060 {
6061 if (pResultMatrix->IsValue( nIndex) &&
6062 pResultMatrix->GetDouble( nIndex))
6063 ++fCount;
6064 }
6065 }
6066 else
6067 {
6068 if(ScCountIfCellIteratorSortedCache::CanBeUsed(mrDoc, rParam, nTab1, pMyFormulaCell,
6069 refData, mrContext))
6070 {
6071 ScCountIfCellIteratorSortedCache aCellIter(mrDoc, mrContext, nTab1, rParam, false, false);
6072 fCount += aCellIter.GetCount();
6073 }
6074 else
6075 {
6076 ScCountIfCellIteratorDirect aCellIter(mrDoc, mrContext, nTab1, rParam, false, false);
6077 fCount += aCellIter.GetCount();
6078 }
6079 }
6080 }
6081 else
6082 {
6083 PushIllegalParameter();
6084 return;
6085 }
6086 if (xResMat)
6087 {
6088 xResMat->PutDouble( fCount, 0, nRefListArrayPos);
6089 fCount = 0.0;
6090 }
6091 }
6092 if (xResMat)
6093 PushMatrix( xResMat);
6094 else
6095 PushDouble(fCount);
6096 }
6097
6098 void ScInterpreter::IterateParametersIfs( double(*ResultFunc)( const sc::ParamIfsResult& rRes ) )
6099 {
6100 sal_uInt8 nParamCount = GetByte();
6101 sal_uInt8 nQueryCount = nParamCount / 2;
6102
6103 std::vector<sal_uInt8>& vConditions = mrContext.maConditions;
6104 // vConditions is cached, although it is clear'ed after every cell is interpreted,
6105 // if the SUMIFS/COUNTIFS are part of a matrix formula, then that is not enough because
6106 // with a single InterpretTail() call it results in evaluation of all the cells in the
6107 // matrix formula.
6108 vConditions.clear();
6109
6110 // Range-reduce optimization
6111 SCCOL nStartColDiff = 0;
6112 SCCOL nEndColDiff = 0;
6113 SCROW nStartRowDiff = 0;
6114 SCROW nEndRowDiff = 0;
6115 bool bRangeReduce = false;
6116 ScRange aMainRange;
6117
6118 bool bHasDoubleRefCriteriaRanges = true;
6119 // Do not attempt main-range reduce if any of the criteria-ranges are not double-refs.
6120 // For COUNTIFS queries it's possible to range-reduce too, if the query is not supposed
6121 // to match empty cells (will be checked and undone later if needed), so simply treat
6122 // the first criteria range as the main range for purposes of detecting if this can be done.
6123 for (sal_uInt16 nParamIdx = 2; nParamIdx < nParamCount; nParamIdx += 2 )
6124 {
6125 const formula::FormulaToken* pCriteriaRangeToken = pStack[ sp-nParamIdx ];
6126 if (pCriteriaRangeToken->GetType() != svDoubleRef )
6127 {
6128 bHasDoubleRefCriteriaRanges = false;
6129 break;
6130 }
6131 }
6132
6133 // Probe the main range token, and try if we can shrink the range without altering results.
6134 const formula::FormulaToken* pMainRangeToken = pStack[ sp-nParamCount ];
6135 if (pMainRangeToken->GetType() == svDoubleRef && bHasDoubleRefCriteriaRanges)
6136 {
6137 const ScComplexRefData* pRefData = pMainRangeToken->GetDoubleRef();
6138 if (!pRefData->IsDeleted())
6139 {
6140 DoubleRefToRange( *pRefData, aMainRange);
6141 if (aMainRange.aStart.Tab() == aMainRange.aEnd.Tab())
6142 {
6143 // Shrink the range to actual data content.
6144 ScRange aSubRange = aMainRange;
6145 mrDoc.GetDataAreaSubrange(aSubRange);
6146 nStartColDiff = aSubRange.aStart.Col() - aMainRange.aStart.Col();
6147 nStartRowDiff = aSubRange.aStart.Row() - aMainRange.aStart.Row();
6148 nEndColDiff = aSubRange.aEnd.Col() - aMainRange.aEnd.Col();
6149 nEndRowDiff = aSubRange.aEnd.Row() - aMainRange.aEnd.Row();
6150 bRangeReduce = nStartColDiff || nStartRowDiff || nEndColDiff || nEndRowDiff;
6151 }
6152 }
6153 }
6154
6155 double fVal = 0.0;
6156 SCCOL nDimensionCols = 0;
6157 SCROW nDimensionRows = 0;
6158 const SCSIZE nRefArrayRows = GetRefListArrayMaxSize( nParamCount);
6159 std::vector<std::vector<sal_uInt8>> vRefArrayConditions;
6160
6161 while (nParamCount > 1 && nGlobalError == FormulaError::NONE)
6162 {
6163 // take criteria
6164 svl::SharedString aString;
6165 fVal = 0.0;
6166 bool bIsString = true;
6167 switch ( GetStackType() )
6168 {
6169 case svDoubleRef :
6170 case svSingleRef :
6171 {
6172 ScAddress aAdr;
6173 if ( !PopDoubleRefOrSingleRef( aAdr ) )
6174 {
6175 PushError( nGlobalError);
6176 return;
6177 }
6178
6179 ScRefCellValue aCell(mrDoc, aAdr);
6180 switch (aCell.getType())
6181 {
6182 case CELLTYPE_VALUE :
6183 fVal = GetCellValue(aAdr, aCell);
6184 bIsString = false;
6185 break;
6186 case CELLTYPE_FORMULA :
6187 if (aCell.getFormula()->IsValue())
6188 {
6189 fVal = GetCellValue(aAdr, aCell);
6190 bIsString = false;
6191 }
6192 else
6193 GetCellString(aString, aCell);
6194 break;
6195 case CELLTYPE_STRING :
6196 case CELLTYPE_EDIT :
6197 GetCellString(aString, aCell);
6198 break;
6199 default:
6200 fVal = 0.0;
6201 bIsString = false;
6202 }
6203 }
6204 break;
6205 case svString:
6206 aString = GetString();
6207 break;
6208 case svMatrix :
6209 case svExternalDoubleRef:
6210 {
6211 ScMatValType nType = GetDoubleOrStringFromMatrix( fVal, aString);
6212 bIsString = ScMatrix::IsRealStringType( nType);
6213 }
6214 break;
6215 case svExternalSingleRef:
6216 {
6217 ScExternalRefCache::TokenRef pToken;
6218 PopExternalSingleRef(pToken);
6219 if (nGlobalError == FormulaError::NONE)
6220 {
6221 if (pToken->GetType() == svDouble)
6222 {
6223 fVal = pToken->GetDouble();
6224 bIsString = false;
6225 }
6226 else
6227 aString = pToken->GetString();
6228 }
6229 }
6230 break;
6231 default:
6232 {
6233 fVal = GetDouble();
6234 bIsString = false;
6235 }
6236 }
6237
6238 if (nGlobalError != FormulaError::NONE)
6239 {
6240 PushError( nGlobalError);
6241 return; // and bail out, no need to evaluate other arguments
6242 }
6243
6244 // take range
6245 short nParam = nParamCount;
6246 size_t nRefInList = 0;
6247 size_t nRefArrayPos = std::numeric_limits<size_t>::max();
6248 SCCOL nCol1 = 0;
6249 SCROW nRow1 = 0;
6250 SCTAB nTab1 = 0;
6251 SCCOL nCol2 = 0;
6252 SCROW nRow2 = 0;
6253 SCTAB nTab2 = 0;
6254 ScMatrixRef pQueryMatrix;
6255 while (nParam-- == nParamCount)
6256 {
6257 const ScComplexRefData* refData = nullptr;
6258 switch ( GetStackType() )
6259 {
6260 case svRefList :
6261 {
6262 const ScRefListToken* p = dynamic_cast<const ScRefListToken*>(pStack[sp-1]);
6263 if (p && p->IsArrayResult())
6264 {
6265 if (nRefInList == 0)
6266 {
6267 if (vRefArrayConditions.empty())
6268 vRefArrayConditions.resize( nRefArrayRows);
6269 if (!vConditions.empty())
6270 {
6271 // Similar to other reference list array
6272 // handling, add/op the current value to
6273 // all array positions.
6274 for (auto & rVec : vRefArrayConditions)
6275 {
6276 if (rVec.empty())
6277 rVec = vConditions;
6278 else
6279 {
6280 assert(rVec.size() == vConditions.size()); // see dimensions below
6281 for (size_t i=0, n = rVec.size(); i < n; ++i)
6282 {
6283 rVec[i] += vConditions[i];
6284 }
6285 }
6286 }
6287 // Reset condition results.
6288 std::for_each( vConditions.begin(), vConditions.end(),
6289 [](sal_uInt8 & r){ r = 0.0; } );
6290 }
6291 }
6292 nRefArrayPos = nRefInList;
6293 }
6294 refData = GetStackDoubleRef(nRefInList);
6295 ScRange aRange;
6296 PopDoubleRef( aRange, nParam, nRefInList);
6297 aRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
6298 }
6299 break;
6300 case svDoubleRef :
6301 refData = GetStackDoubleRef();
6302 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
6303 break;
6304 case svSingleRef :
6305 PopSingleRef( nCol1, nRow1, nTab1 );
6306 nCol2 = nCol1;
6307 nRow2 = nRow1;
6308 nTab2 = nTab1;
6309 break;
6310 case svMatrix:
6311 case svExternalSingleRef:
6312 case svExternalDoubleRef:
6313 {
6314 pQueryMatrix = GetMatrix();
6315 if (!pQueryMatrix)
6316 {
6317 PushError( FormulaError::IllegalParameter);
6318 return;
6319 }
6320 nCol1 = 0;
6321 nRow1 = 0;
6322 nTab1 = 0;
6323 SCSIZE nC, nR;
6324 pQueryMatrix->GetDimensions( nC, nR);
6325 nCol2 = static_cast<SCCOL>(nC - 1);
6326 nRow2 = static_cast<SCROW>(nR - 1);
6327 nTab2 = 0;
6328 }
6329 break;
6330 default:
6331 PushError( FormulaError::IllegalParameter);
6332 return;
6333 }
6334 if ( nTab1 != nTab2 )
6335 {
6336 PushError( FormulaError::IllegalArgument);
6337 return;
6338 }
6339
6340 ScQueryParam rParam;
6341 ScQueryEntry& rEntry = rParam.GetEntry(0);
6342 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
6343 rEntry.bDoQuery = true;
6344 if (!bIsString)
6345 {
6346 rItem.meType = ScQueryEntry::ByValue;
6347 rItem.mfVal = fVal;
6348 rEntry.eOp = SC_EQUAL;
6349 }
6350 else
6351 {
6352 rParam.FillInExcelSyntax(mrDoc.GetSharedStringPool(), aString.getString(), 0, &mrContext);
6353 if (rItem.meType == ScQueryEntry::ByString)
6354 rParam.eSearchType = DetectSearchType(rItem.maString.getString(), mrDoc);
6355 }
6356
6357 // Undo bRangeReduce if asked to match empty cells for COUNTIFS (which should be rare).
6358 assert(rEntry.GetQueryItems().size() == 1);
6359 const bool isCountIfs = (nParamCount % 2) == 0;
6360 if(isCountIfs && (rEntry.IsQueryByEmpty() || rItem.mbMatchEmpty) && bRangeReduce)
6361 {
6362 bRangeReduce = false;
6363 // All criteria ranges are svDoubleRef's, so only vConditions needs adjusting.
6364 assert(vRefArrayConditions.empty());
6365 if(!vConditions.empty())
6366 {
6367 std::vector<sal_uInt8> newConditions;
6368 SCCOL newDimensionCols = nCol2 - nCol1 + 1;
6369 SCROW newDimensionRows = nRow2 - nRow1 + 1;
6370 newConditions.reserve( newDimensionCols * newDimensionRows );
6371 SCCOL col = nCol1;
6372 for(; col < nCol1 + nStartColDiff; ++col)
6373 newConditions.insert( newConditions.end(), newDimensionRows, 0 );
6374 for(; col <= nCol2 - nStartColDiff; ++col)
6375 {
6376 newConditions.insert( newConditions.end(), nStartRowDiff, 0 );
6377 SCCOL oldCol = col - ( nCol1 + nStartColDiff );
6378 size_t nIndex = oldCol * nDimensionRows;
6379 if (nIndex < vConditions.size())
6380 {
6381 auto it = vConditions.begin() + nIndex;
6382 newConditions.insert( newConditions.end(), it, it + nDimensionRows );
6383 }
6384 else
6385 newConditions.insert( newConditions.end(), nDimensionRows, 0 );
6386 newConditions.insert( newConditions.end(), -nEndRowDiff, 0 );
6387 }
6388 for(; col <= nCol2; ++col)
6389 newConditions.insert( newConditions.end(), newDimensionRows, 0 );
6390 assert( newConditions.size() == o3tl::make_unsigned( newDimensionCols * newDimensionRows ));
6391 vConditions = std::move( newConditions );
6392 nDimensionCols = newDimensionCols;
6393 nDimensionRows = newDimensionRows;
6394 }
6395 }
6396
6397 if (bRangeReduce)
6398 {
6399 // All reference ranges must be of the same size as the main range.
6400 if( aMainRange.aEnd.Col() - aMainRange.aStart.Col() != nCol2 - nCol1
6401 || aMainRange.aEnd.Row() - aMainRange.aStart.Row() != nRow2 - nRow1)
6402 {
6403 PushError ( FormulaError::IllegalArgument);
6404 return;
6405 }
6406 nCol1 += nStartColDiff;
6407 nRow1 += nStartRowDiff;
6408
6409 nCol2 += nEndColDiff;
6410 nRow2 += nEndRowDiff;
6411 }
6412
6413 // All reference ranges must be of same dimension and size.
6414 if (!nDimensionCols)
6415 nDimensionCols = nCol2 - nCol1 + 1;
6416 if (!nDimensionRows)
6417 nDimensionRows = nRow2 - nRow1 + 1;
6418 if ((nDimensionCols != (nCol2 - nCol1 + 1)) || (nDimensionRows != (nRow2 - nRow1 + 1)))
6419 {
6420 PushError ( FormulaError::IllegalArgument);
6421 return;
6422 }
6423
6424 // recalculate matrix values
6425 if (nGlobalError != FormulaError::NONE)
6426 {
6427 PushError( nGlobalError);
6428 return;
6429 }
6430
6431 // initialize temporary result matrix
6432 if (vConditions.empty())
6433 vConditions.resize( nDimensionCols * nDimensionRows, 0);
6434
6435 rParam.nRow1 = nRow1;
6436 rParam.nRow2 = nRow2;
6437 rParam.nCol1 = nCol1;
6438 rParam.nCol2 = nCol2;
6439 rEntry.nField = nCol1;
6440 SCCOL nColDiff = -nCol1;
6441 SCROW nRowDiff = -nRow1;
6442 if (pQueryMatrix)
6443 {
6444 // Never case-sensitive.
6445 sc::CompareOptions aOptions(mrDoc, rEntry, rParam.eSearchType);
6446 ScMatrixRef pResultMatrix = QueryMat( pQueryMatrix, aOptions);
6447 if (nGlobalError != FormulaError::NONE || !pResultMatrix)
6448 {
6449 PushError( FormulaError::IllegalParameter);
6450 return;
6451 }
6452
6453 // result matrix is filled with boolean values.
6454 std::vector<double> aResValues;
6455 pResultMatrix->GetDoubleArray(aResValues);
6456 if (vConditions.size() != aResValues.size())
6457 {
6458 PushError( FormulaError::IllegalParameter);
6459 return;
6460 }
6461
6462 std::vector<double>::const_iterator itThisRes = aResValues.begin();
6463 for (auto& rCondition : vConditions)
6464 {
6465 rCondition += *itThisRes;
6466 ++itThisRes;
6467 }
6468 }
6469 else
6470 {
6471 if( ScQueryCellIteratorSortedCache::CanBeUsed( mrDoc, rParam, nTab1, pMyFormulaCell,
6472 refData, mrContext ))
6473 {
6474 ScQueryCellIteratorSortedCache aCellIter(mrDoc, mrContext, nTab1, rParam, false, false);
6475 // Increment Entry.nField in iterator when switching to next column.
6476 aCellIter.SetAdvanceQueryParamEntryField( true );
6477 if ( aCellIter.GetFirst() )
6478 {
6479 do
6480 {
6481 size_t nC = aCellIter.GetCol() + nColDiff;
6482 size_t nR = aCellIter.GetRow() + nRowDiff;
6483 ++vConditions[nC * nDimensionRows + nR];
6484 } while ( aCellIter.GetNext() );
6485 }
6486 }
6487 else
6488 {
6489 ScQueryCellIteratorDirect aCellIter(mrDoc, mrContext, nTab1, rParam, false, false);
6490 // Increment Entry.nField in iterator when switching to next column.
6491 aCellIter.SetAdvanceQueryParamEntryField( true );
6492 if ( aCellIter.GetFirst() )
6493 {
6494 do
6495 {
6496 size_t nC = aCellIter.GetCol() + nColDiff;
6497 size_t nR = aCellIter.GetRow() + nRowDiff;
6498 ++vConditions[nC * nDimensionRows + nR];
6499 } while ( aCellIter.GetNext() );
6500 }
6501 }
6502 }
6503 if (nRefArrayPos != std::numeric_limits<size_t>::max())
6504 {
6505 // Apply condition result to reference list array result position.
6506 std::vector<sal_uInt8>& rVec = vRefArrayConditions[nRefArrayPos];
6507 if (rVec.empty())
6508 rVec = vConditions;
6509 else
6510 {
6511 assert(rVec.size() == vConditions.size()); // see dimensions above
6512 for (size_t i=0, n = rVec.size(); i < n; ++i)
6513 {
6514 rVec[i] += vConditions[i];
6515 }
6516 }
6517 // Reset conditions vector.
6518 // When leaving an svRefList this has to be emptied not set to
6519 // 0.0 because it's checked when entering an svRefList.
6520 if (nRefInList == 0)
6521 std::vector<sal_uInt8>().swap( vConditions);
6522 else
6523 std::for_each( vConditions.begin(), vConditions.end(), [](sal_uInt8 & r){ r = 0; } );
6524 }
6525 }
6526 nParamCount -= 2;
6527 }
6528
6529 if (!vRefArrayConditions.empty() && !vConditions.empty())
6530 {
6531 // Add/op the last current value to all array positions.
6532 for (auto & rVec : vRefArrayConditions)
6533 {
6534 if (rVec.empty())
6535 rVec = vConditions;
6536 else
6537 {
6538 assert(rVec.size() == vConditions.size()); // see dimensions above
6539 for (size_t i=0, n = rVec.size(); i < n; ++i)
6540 {
6541 rVec[i] += vConditions[i];
6542 }
6543 }
6544 }
6545 }
6546
6547 if (nGlobalError != FormulaError::NONE)
6548 {
6549 PushError( nGlobalError);
6550 return; // bail out
6551 }
6552
6553 sc::ParamIfsResult aRes;
6554 ScMatrixRef xResMat;
6555
6556 // main range - only for AVERAGEIFS, SUMIFS, MINIFS and MAXIFS
6557 if (nParamCount == 1)
6558 {
6559 short nParam = nParamCount;
6560 size_t nRefInList = 0;
6561 size_t nRefArrayPos = std::numeric_limits<size_t>::max();
6562 bool bRefArrayMain = false;
6563 while (nParam-- == nParamCount)
6564 {
6565 SCCOL nMainCol1 = 0;
6566 SCROW nMainRow1 = 0;
6567 SCTAB nMainTab1 = 0;
6568 SCCOL nMainCol2 = 0;
6569 SCROW nMainRow2 = 0;
6570 SCTAB nMainTab2 = 0;
6571 ScMatrixRef pMainMatrix;
6572 switch ( GetStackType() )
6573 {
6574 case svRefList :
6575 {
6576 const ScRefListToken* p = dynamic_cast<const ScRefListToken*>(pStack[sp-1]);
6577 if (p && p->IsArrayResult())
6578 {
6579 if (vRefArrayConditions.empty())
6580 {
6581 // Replicate conditions if there wasn't a
6582 // reference list array for criteria
6583 // evaluation.
6584 vRefArrayConditions.resize( nRefArrayRows);
6585 for (auto & rVec : vRefArrayConditions)
6586 {
6587 rVec = vConditions;
6588 }
6589 }
6590
6591 bRefArrayMain = true;
6592 nRefArrayPos = nRefInList;
6593 }
6594 ScRange aRange;
6595 PopDoubleRef( aRange, nParam, nRefInList);
6596 aRange.GetVars( nMainCol1, nMainRow1, nMainTab1, nMainCol2, nMainRow2, nMainTab2);
6597 }
6598 break;
6599 case svDoubleRef :
6600 PopDoubleRef( nMainCol1, nMainRow1, nMainTab1, nMainCol2, nMainRow2, nMainTab2 );
6601 break;
6602 case svSingleRef :
6603 PopSingleRef( nMainCol1, nMainRow1, nMainTab1 );
6604 nMainCol2 = nMainCol1;
6605 nMainRow2 = nMainRow1;
6606 nMainTab2 = nMainTab1;
6607 break;
6608 case svMatrix:
6609 case svExternalSingleRef:
6610 case svExternalDoubleRef:
6611 {
6612 pMainMatrix = GetMatrix();
6613 if (!pMainMatrix)
6614 {
6615 PushError( FormulaError::IllegalParameter);
6616 return;
6617 }
6618 nMainCol1 = 0;
6619 nMainRow1 = 0;
6620 nMainTab1 = 0;
6621 SCSIZE nC, nR;
6622 pMainMatrix->GetDimensions( nC, nR);
6623 nMainCol2 = static_cast<SCCOL>(nC - 1);
6624 nMainRow2 = static_cast<SCROW>(nR - 1);
6625 nMainTab2 = 0;
6626 }
6627 break;
6628 // Treat a scalar value as 1x1 matrix.
6629 case svDouble:
6630 pMainMatrix = GetNewMat(1,1);
6631 nMainCol1 = nMainCol2 = 0;
6632 nMainRow1 = nMainRow2 = 0;
6633 nMainTab1 = nMainTab2 = 0;
6634 pMainMatrix->PutDouble( GetDouble(), 0, 0);
6635 break;
6636 case svString:
6637 pMainMatrix = GetNewMat(1,1);
6638 nMainCol1 = nMainCol2 = 0;
6639 nMainRow1 = nMainRow2 = 0;
6640 nMainTab1 = nMainTab2 = 0;
6641 pMainMatrix->PutString( GetString(), 0, 0);
6642 break;
6643 default:
6644 PopError();
6645 PushError( FormulaError::IllegalParameter);
6646 return;
6647 }
6648 if ( nMainTab1 != nMainTab2 )
6649 {
6650 PushError( FormulaError::IllegalArgument);
6651 return;
6652 }
6653
6654 if (bRangeReduce)
6655 {
6656 nMainCol1 += nStartColDiff;
6657 nMainRow1 += nStartRowDiff;
6658
6659 nMainCol2 += nEndColDiff;
6660 nMainRow2 += nEndRowDiff;
6661 }
6662
6663 // All reference ranges must be of same dimension and size.
6664 if ((nDimensionCols != (nMainCol2 - nMainCol1 + 1)) || (nDimensionRows != (nMainRow2 - nMainRow1 + 1)))
6665 {
6666 PushError ( FormulaError::IllegalArgument);
6667 return;
6668 }
6669
6670 if (nGlobalError != FormulaError::NONE)
6671 {
6672 PushError( nGlobalError);
6673 return; // bail out
6674 }
6675
6676 // end-result calculation
6677
6678 // This gets weird... if conditions were calculated using a
6679 // reference list array but the main calculation range is not a
6680 // reference list array, then the conditions of the array are
6681 // applied to the main range each in turn to form the array result.
6682
6683 size_t nRefArrayMainPos = (bRefArrayMain ? nRefArrayPos :
6684 (vRefArrayConditions.empty() ? std::numeric_limits<size_t>::max() : 0));
6685 const bool bAppliedArray = (!bRefArrayMain && nRefArrayMainPos == 0);
6686
6687 if (nRefArrayMainPos == 0)
6688 xResMat = GetNewMat( 1, nRefArrayRows, /*bEmpty*/true );
6689
6690 if (pMainMatrix)
6691 {
6692 std::vector<double> aMainValues;
6693 pMainMatrix->GetDoubleArray(aMainValues, false); // Map empty values to NaN's.
6694
6695 do
6696 {
6697 if (nRefArrayMainPos < vRefArrayConditions.size())
6698 vConditions = vRefArrayConditions[nRefArrayMainPos];
6699
6700 if (vConditions.size() != aMainValues.size())
6701 {
6702 PushError( FormulaError::IllegalArgument);
6703 return;
6704 }
6705
6706 std::vector<sal_uInt8>::const_iterator itRes = vConditions.begin(), itResEnd = vConditions.end();
6707 std::vector<double>::const_iterator itMain = aMainValues.begin();
6708 for (; itRes != itResEnd; ++itRes, ++itMain)
6709 {
6710 if (*itRes != nQueryCount)
6711 continue;
6712
6713 fVal = *itMain;
6714 if (GetDoubleErrorValue(fVal) == FormulaError::ElementNaN)
6715 continue;
6716
6717 ++aRes.mfCount;
6718 aRes.mfSum += fVal;
6719 if ( aRes.mfMin > fVal )
6720 aRes.mfMin = fVal;
6721 if ( aRes.mfMax < fVal )
6722 aRes.mfMax = fVal;
6723 }
6724 if (nRefArrayMainPos != std::numeric_limits<size_t>::max())
6725 {
6726 xResMat->PutDouble( ResultFunc( aRes), 0, nRefArrayMainPos);
6727 aRes = sc::ParamIfsResult();
6728 }
6729 }
6730 while (bAppliedArray && ++nRefArrayMainPos < nRefArrayRows);
6731 }
6732 else
6733 {
6734 ScAddress aAdr;
6735 aAdr.SetTab( nMainTab1 );
6736 do
6737 {
6738 if (nRefArrayMainPos < vRefArrayConditions.size())
6739 vConditions = vRefArrayConditions[nRefArrayMainPos];
6740
6741 SAL_WARN_IF(nDimensionCols && nDimensionRows && vConditions.empty(), "sc", "ScInterpreter::IterateParametersIfs vConditions is empty");
6742 if (!vConditions.empty())
6743 {
6744 std::vector<sal_uInt8>::const_iterator itRes = vConditions.begin();
6745 for (SCCOL nCol = 0; nCol < nDimensionCols; ++nCol)
6746 {
6747 for (SCROW nRow = 0; nRow < nDimensionRows; ++nRow, ++itRes)
6748 {
6749 if (*itRes == nQueryCount)
6750 {
6751 aAdr.SetCol( nCol + nMainCol1);
6752 aAdr.SetRow( nRow + nMainRow1);
6753 ScRefCellValue aCell(mrDoc, aAdr);
6754 if (aCell.hasNumeric())
6755 {
6756 fVal = GetCellValue(aAdr, aCell);
6757 ++aRes.mfCount;
6758 aRes.mfSum += fVal;
6759 if ( aRes.mfMin > fVal )
6760 aRes.mfMin = fVal;
6761 if ( aRes.mfMax < fVal )
6762 aRes.mfMax = fVal;
6763 }
6764 }
6765 }
6766 }
6767 }
6768 if (nRefArrayMainPos != std::numeric_limits<size_t>::max())
6769 {
6770 xResMat->PutDouble( ResultFunc( aRes), 0, nRefArrayMainPos);
6771 aRes = sc::ParamIfsResult();
6772 }
6773 }
6774 while (bAppliedArray && ++nRefArrayMainPos < nRefArrayRows);
6775 }
6776 }
6777 }
6778 else
6779 {
6780 // COUNTIFS only.
6781 if (vRefArrayConditions.empty())
6782 {
6783 // The code below is this but optimized for most elements not matching.
6784 // for (auto const & rCond : vConditions)
6785 // if (rCond == nQueryCount)
6786 // ++aRes.mfCount;
6787 static_assert(sizeof(vConditions[0]) == 1);
6788 const sal_uInt8* pos = vConditions.data();
6789 const sal_uInt8* end = pos + vConditions.size();
6790 for(;;)
6791 {
6792 pos = static_cast< const sal_uInt8* >( memchr( pos, nQueryCount, end - pos ));
6793 if( pos == nullptr )
6794 break;
6795 ++aRes.mfCount;
6796 ++pos;
6797 }
6798 }
6799 else
6800 {
6801 xResMat = GetNewMat( 1, nRefArrayRows, /*bEmpty*/true );
6802 for (size_t i=0, n = vRefArrayConditions.size(); i < n; ++i)
6803 {
6804 double fCount = 0.0;
6805 for (auto const & rCond : vRefArrayConditions[i])
6806 {
6807 if (rCond == nQueryCount)
6808 ++fCount;
6809 }
6810 xResMat->PutDouble( fCount, 0, i);
6811 }
6812 }
6813 }
6814
6815 if (xResMat)
6816 PushMatrix( xResMat);
6817 else
6818 PushDouble( ResultFunc( aRes));
6819 }
6820
6821 void ScInterpreter::ScSumIfs()
6822 {
6823 // ScMutationGuard aShouldFail(pDok, ScMutationGuardFlags::CORE);
6824 sal_uInt8 nParamCount = GetByte();
6825
6826 if (nParamCount < 3 || (nParamCount % 2 != 1))
6827 {
6828 PushError( FormulaError::ParameterExpected);
6829 return;
6830 }
6831
6832 auto ResultFunc = []( const sc::ParamIfsResult& rRes )
6833 {
6834 return rRes.mfSum.get();
6835 };
6836 IterateParametersIfs(ResultFunc);
6837 }
6838
6839 void ScInterpreter::ScAverageIfs()
6840 {
6841 sal_uInt8 nParamCount = GetByte();
6842
6843 if (nParamCount < 3 || (nParamCount % 2 != 1))
6844 {
6845 PushError( FormulaError::ParameterExpected);
6846 return;
6847 }
6848
6849 auto ResultFunc = []( const sc::ParamIfsResult& rRes )
6850 {
6851 return sc::div( rRes.mfSum.get(), rRes.mfCount);
6852 };
6853 IterateParametersIfs(ResultFunc);
6854 }
6855
6856 void ScInterpreter::ScCountIfs()
6857 {
6858 sal_uInt8 nParamCount = GetByte();
6859
6860 if (nParamCount < 2 || (nParamCount % 2 != 0))
6861 {
6862 PushError( FormulaError::ParameterExpected);
6863 return;
6864 }
6865
6866 auto ResultFunc = []( const sc::ParamIfsResult& rRes )
6867 {
6868 return rRes.mfCount;
6869 };
6870 IterateParametersIfs(ResultFunc);
6871 }
6872
6873 void ScInterpreter::ScMinIfs_MS()
6874 {
6875 sal_uInt8 nParamCount = GetByte();
6876
6877 if (nParamCount < 3 || (nParamCount % 2 != 1))
6878 {
6879 PushError( FormulaError::ParameterExpected);
6880 return;
6881 }
6882
6883 auto ResultFunc = []( const sc::ParamIfsResult& rRes )
6884 {
6885 return (rRes.mfMin < std::numeric_limits<double>::max()) ? rRes.mfMin : 0.0;
6886 };
6887 IterateParametersIfs(ResultFunc);
6888 }
6889
6890
6891 void ScInterpreter::ScMaxIfs_MS()
6892 {
6893 sal_uInt8 nParamCount = GetByte();
6894
6895 if (nParamCount < 3 || (nParamCount % 2 != 1))
6896 {
6897 PushError( FormulaError::ParameterExpected);
6898 return;
6899 }
6900
6901 auto ResultFunc = []( const sc::ParamIfsResult& rRes )
6902 {
6903 return (rRes.mfMax > std::numeric_limits<double>::lowest()) ? rRes.mfMax : 0.0;
6904 };
6905 IterateParametersIfs(ResultFunc);
6906 }
6907
6908 void ScInterpreter::ScLookup()
6909 {
6910 sal_uInt8 nParamCount = GetByte();
6911 if ( !MustHaveParamCount( nParamCount, 2, 3 ) )
6912 return ;
6913
6914 ScMatrixRef pDataMat = nullptr, pResMat = nullptr;
6915 SCCOL nCol1 = 0, nCol2 = 0, nResCol1 = 0, nResCol2 = 0;
6916 SCROW nRow1 = 0, nRow2 = 0, nResRow1 = 0, nResRow2 = 0;
6917 SCTAB nTab1 = 0, nResTab = 0;
6918 SCSIZE nLenMajor = 0; // length of major direction
6919 bool bVertical = true; // whether to lookup vertically or horizontally
6920
6921 // The third parameter, result array, double, string and reference.
6922 double fResVal = 0.0;
6923 svl::SharedString aResStr;
6924 StackVar eResArrayType = svUnknown;
6925
6926 if (nParamCount == 3)
6927 {
6928 eResArrayType = GetStackType();
6929 switch (eResArrayType)
6930 {
6931 case svDoubleRef:
6932 {
6933 SCTAB nTabJunk;
6934 PopDoubleRef(nResCol1, nResRow1, nResTab,
6935 nResCol2, nResRow2, nTabJunk);
6936 if (nResTab != nTabJunk ||
6937 ((nResRow2 - nResRow1) > 0 && (nResCol2 - nResCol1) > 0))
6938 {
6939 // The result array must be a vector.
6940 PushIllegalParameter();
6941 return;
6942 }
6943 }
6944 break;
6945 case svSingleRef:
6946 PopSingleRef( nResCol1, nResRow1, nResTab);
6947 nResCol2 = nResCol1;
6948 nResRow2 = nResRow1;
6949 break;
6950 case svMatrix:
6951 case svExternalSingleRef:
6952 case svExternalDoubleRef:
6953 {
6954 pResMat = GetMatrix();
6955 if (!pResMat)
6956 {
6957 PushIllegalParameter();
6958 return;
6959 }
6960 SCSIZE nC, nR;
6961 pResMat->GetDimensions(nC, nR);
6962 if (nC != 1 && nR != 1)
6963 {
6964 // Result matrix must be a vector.
6965 PushIllegalParameter();
6966 return;
6967 }
6968 }
6969 break;
6970 case svDouble:
6971 fResVal = GetDouble();
6972 break;
6973 case svString:
6974 aResStr = GetString();
6975 break;
6976 default:
6977 PushIllegalParameter();
6978 return;
6979 }
6980 }
6981
6982 // For double, string and single reference.
6983 double fDataVal = 0.0;
6984 svl::SharedString aDataStr;
6985 ScAddress aDataAdr;
6986 bool bValueData = false;
6987
6988 // Get the data-result range and also determine whether this is vertical
6989 // lookup or horizontal lookup.
6990
6991 StackVar eDataArrayType = GetStackType();
6992 switch (eDataArrayType)
6993 {
6994 case svDoubleRef:
6995 {
6996 SCTAB nTabJunk;
6997 PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTabJunk);
6998 if (nTab1 != nTabJunk)
6999 {
7000 PushIllegalParameter();
7001 return;
7002 }
7003 bVertical = (nRow2 - nRow1) >= (nCol2 - nCol1);
7004 nLenMajor = bVertical ? nRow2 - nRow1 + 1 : nCol2 - nCol1 + 1;
7005 }
7006 break;
7007 case svMatrix:
7008 case svExternalSingleRef:
7009 case svExternalDoubleRef:
7010 {
7011 pDataMat = GetMatrix();
7012 if (!pDataMat)
7013 {
7014 PushIllegalParameter();
7015 return;
7016 }
7017
7018 SCSIZE nC, nR;
7019 pDataMat->GetDimensions(nC, nR);
7020 bVertical = (nR >= nC);
7021 nLenMajor = bVertical ? nR : nC;
7022 }
7023 break;
7024 case svDouble:
7025 {
7026 fDataVal = GetDouble();
7027 bValueData = true;
7028 }
7029 break;
7030 case svString:
7031 {
7032 aDataStr = GetString();
7033 }
7034 break;
7035 case svSingleRef:
7036 {
7037 PopSingleRef( aDataAdr );
7038 ScRefCellValue aCell(mrDoc, aDataAdr);
7039 if (aCell.hasEmptyValue())
7040 {
7041 // Empty cells aren't found anywhere, bail out early.
7042 SetError( FormulaError::NotAvailable);
7043 }
7044 else if (aCell.hasNumeric())
7045 {
7046 fDataVal = GetCellValue(aDataAdr, aCell);
7047 bValueData = true;
7048 }
7049 else
7050 GetCellString(aDataStr, aCell);
7051 }
7052 break;
7053 default:
7054 SetError( FormulaError::IllegalParameter);
7055 }
7056
7057 if (nGlobalError != FormulaError::NONE)
7058 {
7059 PushError( nGlobalError);
7060 return;
7061 }
7062
7063 // Get the lookup value.
7064
7065 ScQueryParam aParam;
7066 ScQueryEntry& rEntry = aParam.GetEntry(0);
7067 if ( !FillEntry(rEntry) )
7068 return;
7069
7070 if ( eDataArrayType == svDouble || eDataArrayType == svString ||
7071 eDataArrayType == svSingleRef )
7072 {
7073 // Delta position for a single value is always 0.
7074
7075 // Found if data <= query, but not if query is string and found data is
7076 // numeric or vice versa. This is how Excel does it but doesn't
7077 // document it.
7078
7079 bool bFound = false;
7080 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
7081
7082 if ( bValueData )
7083 {
7084 if (rItem.meType == ScQueryEntry::ByString)
7085 bFound = false;
7086 else
7087 bFound = (fDataVal <= rItem.mfVal);
7088 }
7089 else
7090 {
7091 if (rItem.meType != ScQueryEntry::ByString)
7092 bFound = false;
7093 else
7094 bFound = (ScGlobal::GetCollator().compareString(aDataStr.getString(), rItem.maString.getString()) <= 0);
7095 }
7096
7097 if (!bFound)
7098 {
7099 PushNA();
7100 return;
7101 }
7102
7103 if (pResMat)
7104 {
7105 if (pResMat->IsValue( 0, 0 ))
7106 PushDouble(pResMat->GetDouble( 0, 0 ));
7107 else
7108 PushString(pResMat->GetString(0, 0));
7109 }
7110 else if (nParamCount == 3)
7111 {
7112 switch (eResArrayType)
7113 {
7114 case svDouble:
7115 PushDouble( fResVal );
7116 break;
7117 case svString:
7118 PushString( aResStr );
7119 break;
7120 case svDoubleRef:
7121 case svSingleRef:
7122 PushCellResultToken( true, ScAddress( nResCol1, nResRow1, nResTab), nullptr, nullptr);
7123 break;
7124 default:
7125 assert(!"ScInterpreter::ScLookup: unhandled eResArrayType, single value data");
7126 PushIllegalParameter();
7127 }
7128 }
7129 else
7130 {
7131 switch (eDataArrayType)
7132 {
7133 case svDouble:
7134 PushDouble( fDataVal );
7135 break;
7136 case svString:
7137 PushString( aDataStr );
7138 break;
7139 case svSingleRef:
7140 PushCellResultToken( true, aDataAdr, nullptr, nullptr);
7141 break;
7142 default:
7143 assert(!"ScInterpreter::ScLookup: unhandled eDataArrayType, single value data");
7144 PushIllegalParameter();
7145 }
7146 }
7147 return;
7148 }
7149
7150 // Now, perform the search to compute the delta position (nDelta).
7151
7152 if (pDataMat)
7153 {
7154 // Data array is given as a matrix.
7155 rEntry.bDoQuery = true;
7156 rEntry.eOp = SC_LESS_EQUAL;
7157 bool bFound = false;
7158
7159 SCSIZE nC, nR;
7160 pDataMat->GetDimensions(nC, nR);
7161
7162 // Do not propagate errors from matrix while copying to vector.
7163 pDataMat->SetErrorInterpreter( nullptr);
7164
7165 // Excel has an undocumented behaviour in that it seems to internally
7166 // sort an interim array (i.e. error values specifically #DIV/0! are
7167 // sorted to the end) or ignore error values that makes these "get last
7168 // non-empty" searches work, e.g. =LOOKUP(2,1/NOT(ISBLANK(A:A)),A:A)
7169 // see tdf#117016
7170 // Instead of sorting a million entries of which mostly only a bunch of
7171 // rows are filled and moving error values to the end which most are
7172 // already anyway, assume the matrix to be sorted except error values
7173 // and omit the coded DoubleError values.
7174 // Do this only for a numeric matrix (that includes errors coded as
7175 // doubles), which covers the case in question.
7176 /* TODO: it's unclear whether this really matches Excel behaviour in
7177 * all constellations or if there are cases that include unsorted error
7178 * values and thus yield arbitrary binary search results or something
7179 * different or whether there are cases where error values are also
7180 * omitted from mixed numeric/string arrays or if it's not an interim
7181 * matrix but a cell range reference instead. */
7182 const bool bOmitErrorValues = (eDataArrayType == svMatrix && pDataMat->IsNumeric());
7183
7184 // In case of non-vector matrix, only search the first row or column.
7185 ScMatrixRef pDataMat2;
7186 std::vector<SCCOLROW> vIndex;
7187 if (bOmitErrorValues)
7188 {
7189 std::vector<double> vArray;
7190 VectorMatrixAccessor aMatAcc(*pDataMat, bVertical);
7191 const SCSIZE nElements = aMatAcc.GetElementCount();
7192 for (SCSIZE i=0; i < nElements; ++i)
7193 {
7194 const double fVal = aMatAcc.GetDouble(i);
7195 if (std::isfinite(fVal))
7196 {
7197 vArray.push_back(fVal);
7198 vIndex.push_back(i);
7199 }
7200 }
7201 if (vArray.empty())
7202 {
7203 PushNA();
7204 return;
7205 }
7206 const size_t nElems = vArray.size();
7207 if (nElems == nElements)
7208 {
7209 // No error value omitted, use as is.
7210 pDataMat2 = pDataMat;
7211 std::vector<SCCOLROW>().swap( vIndex);
7212 }
7213 else
7214 {
7215 nLenMajor = nElems;
7216 if (bVertical)
7217 {
7218 ScMatrixRef pTempMat = GetNewMat( 1, nElems, /*bEmpty*/true );
7219 pTempMat->PutDoubleVector( vArray, 0, 0);
7220 pDataMat2 = pTempMat;
7221 }
7222 else
7223 {
7224 ScMatrixRef pTempMat = GetNewMat( nElems, 1, /*bEmpty*/true );
7225 for (size_t i=0; i < nElems; ++i)
7226 pTempMat->PutDouble( vArray[i], i, 0);
7227 pDataMat2 = pTempMat;
7228 }
7229 }
7230 }
7231 else
7232 {
7233 // Just use as is with the VectorMatrixAccessor.
7234 pDataMat2 = pDataMat;
7235 }
7236
7237 // Do not propagate errors from matrix while searching.
7238 pDataMat2->SetErrorInterpreter( nullptr);
7239
7240 VectorMatrixAccessor aMatAcc2(*pDataMat2, bVertical);
7241
7242 // binary search for non-equality mode (the source data is
7243 // assumed to be sorted in ascending order).
7244
7245 SCCOLROW nDelta = -1;
7246 bool bMatchWholeCell = mrDoc.GetDocOptions().IsMatchWholeCell();
7247
7248 SCSIZE nFirst = 0, nLast = nLenMajor-1; //, nHitIndex = 0;
7249 for (SCSIZE nLen = nLast-nFirst; nLen > 0; nLen = nLast-nFirst)
7250 {
7251 SCSIZE nMid = nFirst + nLen/2;
7252 sal_Int32 nCmp = lcl_CompareMatrix2Query( nMid, aMatAcc2, aParam, rEntry, bMatchWholeCell );
7253 if (nCmp == 0)
7254 {
7255 // exact match. find the last item with the same value.
7256 lcl_GetLastMatch( nMid, aMatAcc2, nLenMajor);
7257 nDelta = nMid;
7258 bFound = true;
7259 break;
7260 }
7261
7262 if (nLen == 1) // first and last items are next to each other.
7263 {
7264 nDelta = nCmp < 0 ? nLast - 1 : nFirst - 1;
7265 // If already the 1st item is greater there's nothing found.
7266 bFound = (nDelta >= 0);
7267 break;
7268 }
7269
7270 if (nCmp < 0)
7271 nFirst = nMid;
7272 else
7273 nLast = nMid;
7274 }
7275
7276 if (nDelta == static_cast<SCCOLROW>(nLenMajor-2)) // last item
7277 {
7278 sal_Int32 nCmp = lcl_CompareMatrix2Query(nDelta+1, aMatAcc2, aParam, rEntry, bMatchWholeCell );
7279 if (nCmp <= 0)
7280 {
7281 // either the last item is an exact match or the real
7282 // hit is beyond the last item.
7283 nDelta += 1;
7284 bFound = true;
7285 }
7286 }
7287 else if (nDelta > 0) // valid hit must be 2nd item or higher
7288 {
7289 // non-exact match
7290 bFound = true;
7291 }
7292
7293 // With 0-9 < A-Z, if query is numeric and data found is string, or
7294 // vice versa, the (yet another undocumented) Excel behavior is to
7295 // return #N/A instead.
7296
7297 if (bFound)
7298 {
7299 if (!vIndex.empty())
7300 nDelta = vIndex[nDelta];
7301
7302 VectorMatrixAccessor aMatAcc(*pDataMat, bVertical);
7303 SCCOLROW i = nDelta;
7304 SCSIZE n = aMatAcc.GetElementCount();
7305 if (o3tl::make_unsigned(i) >= n)
7306 i = static_cast<SCCOLROW>(n);
7307 bool bByString = rEntry.GetQueryItem().meType == ScQueryEntry::ByString;
7308 if (bByString == aMatAcc.IsValue(i))
7309 bFound = false;
7310 }
7311
7312 if (!bFound)
7313 {
7314 PushNA();
7315 return;
7316 }
7317
7318 // Now that we've found the delta, push the result back to the cell.
7319
7320 if (pResMat)
7321 {
7322 VectorMatrixAccessor aResMatAcc(*pResMat, bVertical);
7323 // Result array is matrix.
7324 // Note this does not replicate the other dimension.
7325 if (o3tl::make_unsigned(nDelta) >= aResMatAcc.GetElementCount())
7326 {
7327 PushNA();
7328 return;
7329 }
7330 if (aResMatAcc.IsValue(nDelta))
7331 PushDouble(aResMatAcc.GetDouble(nDelta));
7332 else
7333 PushString(aResMatAcc.GetString(nDelta));
7334 }
7335 else if (nParamCount == 3)
7336 {
7337 /* TODO: the entire switch is a copy of the cell range search
7338 * result, factor out. */
7339 switch (eResArrayType)
7340 {
7341 case svDoubleRef:
7342 case svSingleRef:
7343 {
7344 // Use the result array vector. Note that the result array is assumed
7345 // to be a vector (i.e. 1-dimensional array).
7346
7347 ScAddress aAdr;
7348 aAdr.SetTab(nResTab);
7349 bool bResVertical = (nResRow2 - nResRow1) > 0;
7350 if (bResVertical)
7351 {
7352 SCROW nTempRow = static_cast<SCROW>(nResRow1 + nDelta);
7353 if (nTempRow > mrDoc.MaxRow())
7354 {
7355 PushDouble(0);
7356 return;
7357 }
7358 aAdr.SetCol(nResCol1);
7359 aAdr.SetRow(nTempRow);
7360 }
7361 else
7362 {
7363 SCCOL nTempCol = static_cast<SCCOL>(nResCol1 + nDelta);
7364 if (nTempCol > mrDoc.MaxCol())
7365 {
7366 PushDouble(0);
7367 return;
7368 }
7369 aAdr.SetCol(nTempCol);
7370 aAdr.SetRow(nResRow1);
7371 }
7372 PushCellResultToken( true, aAdr, nullptr, nullptr);
7373 }
7374 break;
7375 case svDouble:
7376 case svString:
7377 {
7378 if (nDelta != 0)
7379 PushNA();
7380 else
7381 {
7382 switch (eResArrayType)
7383 {
7384 case svDouble:
7385 PushDouble( fResVal );
7386 break;
7387 case svString:
7388 PushString( aResStr );
7389 break;
7390 default:
7391 ; // nothing
7392 }
7393 }
7394 }
7395 break;
7396 default:
7397 assert(!"ScInterpreter::ScLookup: unhandled eResArrayType, array search");
7398 PushIllegalParameter();
7399 }
7400 }
7401 else
7402 {
7403 // No result array. Use the data array to get the final value from.
7404 // Propagate errors from matrix again.
7405 pDataMat->SetErrorInterpreter( this);
7406 if (bVertical)
7407 {
7408 if (pDataMat->IsValue(nC-1, nDelta))
7409 PushDouble(pDataMat->GetDouble(nC-1, nDelta));
7410 else
7411 PushString(pDataMat->GetString(nC-1, nDelta));
7412 }
7413 else
7414 {
7415 if (pDataMat->IsValue(nDelta, nR-1))
7416 PushDouble(pDataMat->GetDouble(nDelta, nR-1));
7417 else
7418 PushString(pDataMat->GetString(nDelta, nR-1));
7419 }
7420 }
7421
7422 return;
7423 }
7424
7425 // Perform cell range search.
7426
7427 aParam.nCol1 = nCol1;
7428 aParam.nRow1 = nRow1;
7429 aParam.nCol2 = bVertical ? nCol1 : nCol2;
7430 aParam.nRow2 = bVertical ? nRow2 : nRow1;
7431 aParam.bByRow = bVertical;
7432
7433 rEntry.bDoQuery = true;
7434 rEntry.eOp = SC_LESS_EQUAL;
7435 rEntry.nField = nCol1;
7436 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
7437 if (rItem.meType == ScQueryEntry::ByString)
7438 aParam.eSearchType = DetectSearchType(rItem.maString.getString(), mrDoc);
7439
7440 ScQueryCellIteratorDirect aCellIter(mrDoc, mrContext, nTab1, aParam, false, false);
7441 SCCOL nC;
7442 SCROW nR;
7443 // Advance Entry.nField in iterator upon switching columns if
7444 // lookup in row.
7445 aCellIter.SetAdvanceQueryParamEntryField(!bVertical);
7446 if ( !aCellIter.FindEqualOrSortedLastInRange(nC, nR) )
7447 {
7448 PushNA();
7449 return;
7450 }
7451
7452 SCCOLROW nDelta = bVertical ? static_cast<SCSIZE>(nR-nRow1) : static_cast<SCSIZE>(nC-nCol1);
7453
7454 if (pResMat)
7455 {
7456 VectorMatrixAccessor aResMatAcc(*pResMat, bVertical);
7457 // Use the matrix result array.
7458 // Note this does not replicate the other dimension.
7459 if (o3tl::make_unsigned(nDelta) >= aResMatAcc.GetElementCount())
7460 {
7461 PushNA();
7462 return;
7463 }
7464 if (aResMatAcc.IsValue(nDelta))
7465 PushDouble(aResMatAcc.GetDouble(nDelta));
7466 else
7467 PushString(aResMatAcc.GetString(nDelta));
7468 }
7469 else if (nParamCount == 3)
7470 {
7471 /* TODO: the entire switch is a copy of the array search result, factor
7472 * out. */
7473 switch (eResArrayType)
7474 {
7475 case svDoubleRef:
7476 case svSingleRef:
7477 {
7478 // Use the result array vector. Note that the result array is assumed
7479 // to be a vector (i.e. 1-dimensional array).
7480
7481 ScAddress aAdr;
7482 aAdr.SetTab(nResTab);
7483 bool bResVertical = (nResRow2 - nResRow1) > 0;
7484 if (bResVertical)
7485 {
7486 SCROW nTempRow = static_cast<SCROW>(nResRow1 + nDelta);
7487 if (nTempRow > mrDoc.MaxRow())
7488 {
7489 PushDouble(0);
7490 return;
7491 }
7492 aAdr.SetCol(nResCol1);
7493 aAdr.SetRow(nTempRow);
7494 }
7495 else
7496 {
7497 SCCOL nTempCol = static_cast<SCCOL>(nResCol1 + nDelta);
7498 if (nTempCol > mrDoc.MaxCol())
7499 {
7500 PushDouble(0);
7501 return;
7502 }
7503 aAdr.SetCol(nTempCol);
7504 aAdr.SetRow(nResRow1);
7505 }
7506 PushCellResultToken( true, aAdr, nullptr, nullptr);
7507 }
7508 break;
7509 case svDouble:
7510 case svString:
7511 {
7512 if (nDelta != 0)
7513 PushNA();
7514 else
7515 {
7516 switch (eResArrayType)
7517 {
7518 case svDouble:
7519 PushDouble( fResVal );
7520 break;
7521 case svString:
7522 PushString( aResStr );
7523 break;
7524 default:
7525 ; // nothing
7526 }
7527 }
7528 }
7529 break;
7530 default:
7531 assert(!"ScInterpreter::ScLookup: unhandled eResArrayType, range search");
7532 PushIllegalParameter();
7533 }
7534 }
7535 else
7536 {
7537 // Regardless of whether or not the result array exists, the last
7538 // array is always used as the "result" array.
7539
7540 ScAddress aAdr;
7541 aAdr.SetTab(nTab1);
7542 if (bVertical)
7543 {
7544 SCROW nTempRow = static_cast<SCROW>(nRow1 + nDelta);
7545 if (nTempRow > mrDoc.MaxRow())
7546 {
7547 PushDouble(0);
7548 return;
7549 }
7550 aAdr.SetCol(nCol2);
7551 aAdr.SetRow(nTempRow);
7552 }
7553 else
7554 {
7555 SCCOL nTempCol = static_cast<SCCOL>(nCol1 + nDelta);
7556 if (nTempCol > mrDoc.MaxCol())
7557 {
7558 PushDouble(0);
7559 return;
7560 }
7561 aAdr.SetCol(nTempCol);
7562 aAdr.SetRow(nRow2);
7563 }
7564 PushCellResultToken(true, aAdr, nullptr, nullptr);
7565 }
7566 }
7567
7568 void ScInterpreter::ScHLookup()
7569 {
7570 CalculateLookup(true);
7571 }
7572
7573 void ScInterpreter::CalculateLookup(bool bHLookup)
7574 {
7575 sal_uInt8 nParamCount = GetByte();
7576 if (!MustHaveParamCount(nParamCount, 3, 4))
7577 return;
7578
7579 // Optional 4th argument to declare whether or not the range is sorted.
7580 bool bSorted = true;
7581 if (nParamCount == 4)
7582 bSorted = GetBool();
7583
7584 // Index of column to search.
7585 double fIndex = ::rtl::math::approxFloor( GetDouble() ) - 1.0;
7586
7587 ScMatrixRef pMat = nullptr;
7588 SCSIZE nC = 0, nR = 0;
7589 SCCOL nCol1 = 0;
7590 SCROW nRow1 = 0;
7591 SCTAB nTab1 = 0;
7592 SCCOL nCol2 = 0;
7593 SCROW nRow2 = 0;
7594 const ScComplexRefData* refData = nullptr;
7595 StackVar eType = GetStackType();
7596 if (eType == svDoubleRef)
7597 {
7598 refData = GetStackDoubleRef(0);
7599 SCTAB nTab2;
7600 PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
7601 if (nTab1 != nTab2)
7602 {
7603 PushIllegalParameter();
7604 return;
7605 }
7606 }
7607 else if (eType == svSingleRef)
7608 {
7609 PopSingleRef(nCol1, nRow1, nTab1);
7610 nCol2 = nCol1;
7611 nRow2 = nRow1;
7612 }
7613 else if (eType == svMatrix || eType == svExternalDoubleRef || eType == svExternalSingleRef)
7614 {
7615 pMat = GetMatrix();
7616
7617 if (pMat)
7618 pMat->GetDimensions(nC, nR);
7619 else
7620 {
7621 PushIllegalParameter();
7622 return;
7623 }
7624 }
7625 else
7626 {
7627 PushIllegalParameter();
7628 return;
7629 }
7630
7631 if ( fIndex < 0.0 || (bHLookup ? (pMat ? (fIndex >= nR) : (fIndex+nRow1 > nRow2)) : (pMat ? (fIndex >= nC) : (fIndex+nCol1 > nCol2)) ) )
7632 {
7633 PushIllegalArgument();
7634 return;
7635 }
7636
7637 SCROW nZIndex = static_cast<SCROW>(fIndex);
7638 SCCOL nSpIndex = static_cast<SCCOL>(fIndex);
7639
7640 if (!pMat)
7641 {
7642 nZIndex += nRow1; // value row
7643 nSpIndex = sal::static_int_cast<SCCOL>( nSpIndex + nCol1 ); // value column
7644 }
7645
7646 if (nGlobalError != FormulaError::NONE)
7647 {
7648 PushIllegalParameter();
7649 return;
7650 }
7651
7652 ScQueryParam aParam;
7653 aParam.nCol1 = nCol1;
7654 aParam.nRow1 = nRow1;
7655 if ( bHLookup )
7656 {
7657 aParam.nCol2 = nCol2;
7658 aParam.nRow2 = nRow1; // search only in the first row
7659 aParam.bByRow = false;
7660 }
7661 else
7662 {
7663 aParam.nCol2 = nCol1; // search only in the first column
7664 aParam.nRow2 = nRow2;
7665 aParam.nTab = nTab1;
7666 }
7667
7668 ScQueryEntry& rEntry = aParam.GetEntry(0);
7669 rEntry.bDoQuery = true;
7670 if ( bSorted )
7671 rEntry.eOp = SC_LESS_EQUAL;
7672 if ( !FillEntry(rEntry) )
7673 return;
7674
7675 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
7676 svl::SharedString aParamStr;
7677 if (rItem.meType == ScQueryEntry::ByString)
7678 {
7679 aParam.eSearchType = DetectSearchType(rItem.maString.getString(), mrDoc);
7680 aParamStr = rItem.maString;
7681 }
7682
7683 if (pMat)
7684 {
7685 SCSIZE nMatCount = bHLookup ? nC : nR;
7686 SCSIZE nDelta = SCSIZE_MAX;
7687 if (rItem.meType == ScQueryEntry::ByString)
7688 {
7689 //!!!!!!!
7690 //TODO: enable regex on matrix strings
7691 //!!!!!!!
7692 if ( bSorted )
7693 {
7694 CollatorWrapper& rCollator = ScGlobal::GetCollator();
7695 for (SCSIZE i = 0; i < nMatCount; i++)
7696 {
7697 if (bHLookup ? pMat->IsStringOrEmpty(i, 0) : pMat->IsStringOrEmpty(0, i))
7698 {
7699 sal_Int32 nRes =
7700 rCollator.compareString(
7701 bHLookup ? pMat->GetString(i,0).getString() : pMat->GetString(0,i).getString(), aParamStr.getString());
7702 if (nRes <= 0)
7703 nDelta = i;
7704 else if (i>0) // #i2168# ignore first mismatch
7705 i = nMatCount+1;
7706 }
7707 else
7708 nDelta = i;
7709 }
7710 }
7711 else
7712 {
7713 if (bHLookup)
7714 {
7715 for (SCSIZE i = 0; i < nMatCount; i++)
7716 {
7717 if (pMat->IsStringOrEmpty(i, 0))
7718 {
7719 if (pMat->GetString(i,0).getDataIgnoreCase() == aParamStr.getDataIgnoreCase())
7720 {
7721 nDelta = i;
7722 i = nMatCount + 1;
7723 }
7724 }
7725 }
7726 }
7727 else
7728 {
7729 nDelta = pMat->MatchStringInColumns(aParamStr, 0, 0);
7730 }
7731 }
7732 }
7733 else
7734 {
7735 if ( bSorted )
7736 {
7737 // #i2168# ignore strings
7738 for (SCSIZE i = 0; i < nMatCount; i++)
7739 {
7740 if (!(bHLookup ? pMat->IsStringOrEmpty(i, 0) : pMat->IsStringOrEmpty(0, i)))
7741 {
7742 if ((bHLookup ? pMat->GetDouble(i,0) : pMat->GetDouble(0,i)) <= rItem.mfVal)
7743 nDelta = i;
7744 else
7745 i = nMatCount+1;
7746 }
7747 }
7748 }
7749 else
7750 {
7751 if (bHLookup)
7752 {
7753 for (SCSIZE i = 0; i < nMatCount; i++)
7754 {
7755 if (! pMat->IsStringOrEmpty(i, 0) )
7756 {
7757 if ( pMat->GetDouble(i,0) == rItem.mfVal)
7758 {
7759 nDelta = i;
7760 i = nMatCount + 1;
7761 }
7762 }
7763 }
7764 }
7765 else
7766 {
7767 nDelta = pMat->MatchDoubleInColumns(rItem.mfVal, 0, 0);
7768 }
7769 }
7770 }
7771 if ( nDelta != SCSIZE_MAX )
7772 {
7773 SCSIZE nX = static_cast<SCSIZE>(nSpIndex);
7774 SCSIZE nY = nDelta;
7775 SCSIZE nXs = 0;
7776 SCSIZE nYs = nY;
7777 if ( bHLookup )
7778 {
7779 nX = nDelta;
7780 nY = static_cast<SCSIZE>(nZIndex);
7781 nXs = nX;
7782 nYs = 0;
7783 }
7784 assert( nX < nC && nY < nR );
7785 if (!(rItem.meType == ScQueryEntry::ByString && pMat->IsValue( nXs, nYs)))
7786 {
7787 if (pMat->IsStringOrEmpty( nX, nY))
7788 PushString(pMat->GetString( nX, nY).getString());
7789 else
7790 PushDouble(pMat->GetDouble( nX, nY));
7791 }
7792 else
7793 PushNA();
7794 return;
7795 }
7796 else
7797 PushNA();
7798 }
7799 else
7800 {
7801 // not a matrix
7802 rEntry.nField = nCol1;
7803 bool bFound = false;
7804 SCCOL nCol = 0;
7805 SCROW nRow = 0;
7806 if ( bSorted )
7807 rEntry.eOp = SC_LESS_EQUAL;
7808 if ( bHLookup )
7809 {
7810 ScQueryCellIteratorDirect aCellIter(mrDoc, mrContext, nTab1, aParam, false, false);
7811 // advance Entry.nField in Iterator upon switching columns
7812 aCellIter.SetAdvanceQueryParamEntryField( true );
7813 if ( bSorted )
7814 {
7815 SCROW nRow1_temp;
7816 bFound = aCellIter.FindEqualOrSortedLastInRange( nCol, nRow1_temp );
7817 }
7818 else if ( aCellIter.GetFirst() )
7819 {
7820 bFound = true;
7821 nCol = aCellIter.GetCol();
7822 }
7823 nRow = nZIndex;
7824 }
7825 else
7826 {
7827 ScAddress aResultPos( nCol1, nRow1, nTab1);
7828 bFound = LookupQueryWithCache( aResultPos, aParam, refData, 0, SC_OPCODE_V_LOOKUP );
7829 nRow = aResultPos.Row();
7830 nCol = nSpIndex;
7831 }
7832
7833 if ( bFound )
7834 {
7835 ScAddress aAdr( nCol, nRow, nTab1 );
7836 PushCellResultToken( true, aAdr, nullptr, nullptr);
7837 }
7838 else
7839 PushNA();
7840 }
7841 }
7842
7843 bool ScInterpreter::FillEntry(ScQueryEntry& rEntry)
7844 {
7845 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
7846 switch ( GetStackType() )
7847 {
7848 case svDouble:
7849 {
7850 rItem.meType = ScQueryEntry::ByValue;
7851 rItem.mfVal = GetDouble();
7852 }
7853 break;
7854 case svString:
7855 {
7856 rItem.meType = ScQueryEntry::ByString;
7857 rItem.maString = GetString();
7858 }
7859 break;
7860 case svDoubleRef :
7861 case svSingleRef :
7862 {
7863 ScAddress aAdr;
7864 if ( !PopDoubleRefOrSingleRef( aAdr ) )
7865 {
7866 PushInt(0);
7867 return false;
7868 }
7869 ScRefCellValue aCell(mrDoc, aAdr);
7870 if (aCell.hasNumeric())
7871 {
7872 rItem.meType = ScQueryEntry::ByValue;
7873 rItem.mfVal = GetCellValue(aAdr, aCell);
7874 }
7875 else
7876 {
7877 GetCellString(rItem.maString, aCell);
7878 rItem.meType = ScQueryEntry::ByString;
7879 }
7880 }
7881 break;
7882 case svExternalDoubleRef:
7883 case svExternalSingleRef:
7884 case svMatrix:
7885 {
7886 svl::SharedString aStr;
7887 const ScMatValType nType = GetDoubleOrStringFromMatrix(rItem.mfVal, aStr);
7888 rItem.maString = aStr;
7889 rItem.meType = ScMatrix::IsNonValueType(nType) ?
7890 ScQueryEntry::ByString : ScQueryEntry::ByValue;
7891 }
7892 break;
7893 default:
7894 {
7895 PushIllegalParameter();
7896 return false;
7897 }
7898 } // switch ( GetStackType() )
7899 return true;
7900 }
7901
7902 void ScInterpreter::ScVLookup()
7903 {
7904 CalculateLookup(false);
7905 }
7906
7907 void ScInterpreter::ScXLookup()
7908 {
7909 /* TODO
7910 -use VectorSearchArguments and SearchVectorForValue() with ScLookup, ScHLookup and ScVLookup
7911 as well to reduce redundant code, can de done later with lots of other MATCH/LOOKUP related code
7912 that can be unified
7913 -BinarySearch not supported for columns (horizontal search), now just use linear mode in this case
7914 -improve efficiency of code
7915 */
7916 sal_uInt8 nParamCount = GetByte();
7917 if ( !MustHaveParamCount( nParamCount, 3, 6 ) )
7918 return;
7919
7920 VectorSearchArguments vsa;
7921 vsa.nSearchOpCode = SC_OPCODE_X_LOOKUP;
7922
7923 if ( nParamCount == 6 )
7924 {
7925 sal_Int16 k = GetInt16();
7926 if ( k >= -2 && k <= 2 && k != 0 )
7927 vsa.eSearchMode = static_cast<SearchMode>(k);
7928 else
7929 {
7930 PushIllegalParameter();
7931 return;
7932 }
7933 }
7934 else
7935 vsa.eSearchMode = searchfwd;
7936
7937 if ( nParamCount >= 5 )
7938 {
7939 sal_Int16 k = GetInt16();
7940 if ( k >= -1 && k <= 3 )
7941 vsa.eMatchMode = static_cast<MatchMode>(k);
7942 else
7943 {
7944 PushIllegalParameter();
7945 return;
7946 }
7947 }
7948 else
7949 vsa.eMatchMode = exactorNA;
7950
7951 // Optional 4th argument to set return values if not found (default is #N/A)
7952 formula::FormulaConstTokenRef xNotFound;
7953 FormulaError nFirstMatchError = FormulaError::NONE;
7954 if ( nParamCount >= 4 && GetStackType() != svEmptyCell )
7955 {
7956 xNotFound = PopToken();
7957 nFirstMatchError = xNotFound->GetError();
7958 nGlobalError = FormulaError::NONE; // propagate only for match or active result path
7959 }
7960
7961 // 3rd argument is return value array
7962 ScMatrixRef prMat = nullptr;
7963 SCCOL nSearchCol1 = 0;
7964 SCROW nSearchRow1 = 0;
7965 SCTAB nSearchTab1 = 0;
7966 SCCOL nSearchCol2 = 0;
7967 SCROW nSearchRow2 = 0;
7968 SCTAB nSearchTab2 = 0;
7969 SCSIZE nrC = 0, nrR = 0;
7970
7971 switch ( GetStackType() )
7972 {
7973 case svSingleRef :
7974 PopSingleRef(nSearchCol1, nSearchRow1, nSearchTab1);
7975 nSearchCol2 = nSearchCol1;
7976 nSearchRow2 = nSearchRow1;
7977 nrC = nSearchCol2 - nSearchCol1 + 1;
7978 nrR = nSearchRow2 - nSearchRow1 + 1;
7979 break;
7980 case svDoubleRef:
7981 {
7982 PopDoubleRef(nSearchCol1, nSearchRow1, nSearchTab1, nSearchCol2, nSearchRow2, nSearchTab2);
7983 if (nSearchTab1 != nSearchTab2)
7984 {
7985 PushIllegalParameter();
7986 return;
7987 }
7988 nrC = nSearchCol2 - nSearchCol1 + 1;
7989 nrR = nSearchRow2 - nSearchRow1 + 1;
7990 }
7991 break;
7992 case svMatrix :
7993 case svExternalDoubleRef :
7994 {
7995 if (GetStackType() == svMatrix)
7996 prMat = PopMatrix();
7997 else
7998 PopExternalDoubleRef(prMat);
7999
8000 if (!prMat)
8001 {
8002 PushIllegalParameter();
8003 return;
8004 }
8005 prMat->GetDimensions(nrC, nrR);
8006 }
8007 break;
8008
8009 default :
8010 PushIllegalParameter();
8011 return;
8012 }
8013
8014 // 2nd argument is vector to be searched
8015 SCSIZE nsC = 0, nsR = 0;
8016 switch ( GetStackType() )
8017 {
8018 case svSingleRef:
8019 vsa.pMatSrc = nullptr;
8020 PopSingleRef( vsa.nCol1, vsa.nRow1, vsa.nTab1);
8021 vsa.nCol2 = vsa.nCol1;
8022 vsa.nRow2 = vsa.nRow1;
8023 nsC = vsa.nCol2 - vsa.nCol1 + 1;
8024 nsR = vsa.nRow2 - vsa.nRow1 + 1;
8025 break;
8026 case svDoubleRef:
8027 {
8028 vsa.pMatSrc = nullptr;
8029 SCTAB nTab2 = 0;
8030 PopDoubleRef(vsa.nCol1, vsa.nRow1, vsa.nTab1, vsa.nCol2, vsa.nRow2, nTab2);
8031 if (vsa.nTab1 != nTab2 || (vsa.nCol1 != vsa.nCol2 && vsa.nRow1 != vsa.nRow2))
8032 {
8033 PushIllegalParameter();
8034 return;
8035 }
8036 nsC = vsa.nCol2 - vsa.nCol1 + 1;
8037 nsR = vsa.nRow2 - vsa.nRow1 + 1;
8038 }
8039 break;
8040 case svMatrix:
8041 case svExternalDoubleRef:
8042 {
8043 if (GetStackType() == svMatrix)
8044 vsa.pMatSrc = PopMatrix();
8045 else
8046 PopExternalDoubleRef(vsa.pMatSrc);
8047
8048 if (!vsa.pMatSrc)
8049 {
8050 PushIllegalParameter();
8051 return;
8052 }
8053 vsa.pMatSrc->GetDimensions( nsC, nsR);
8054 }
8055 break;
8056
8057 default:
8058 PushIllegalParameter();
8059 return;
8060 }
8061 if ( ( nsR >= nsC && nsR != nrR ) || ( nsR < nsC && nsC != nrC ) )
8062 {
8063 // search matrix must have same number of elements as result matrix in search direction
8064 PushIllegalParameter();
8065 return;
8066 }
8067
8068 // 1st argument is search value
8069 if (nGlobalError == FormulaError::NONE)
8070 {
8071 switch ( GetRawStackType() )
8072 {
8073 case svMissing:
8074 case svEmptyCell:
8075 {
8076 vsa.isEmptySearch = true;
8077 vsa.isStringSearch = false;
8078 vsa.sSearchStr = GetString();
8079 }
8080 break;
8081
8082 case svDouble:
8083 {
8084 vsa.isStringSearch = false;
8085 vsa.fSearchVal = GetDouble();
8086 }
8087 break;
8088
8089 case svString:
8090 {
8091 vsa.isStringSearch = true;
8092 vsa.sSearchStr = GetString();
8093 }
8094 break;
8095
8096 case svDoubleRef :
8097 case svSingleRef :
8098 {
8099 ScAddress aAdr;
8100 if ( !PopDoubleRefOrSingleRef( aAdr ) )
8101 {
8102 PushInt(0);
8103 return ;
8104 }
8105 ScRefCellValue aCell(mrDoc, aAdr);
8106 if (aCell.hasNumeric())
8107 {
8108 vsa.isStringSearch = false;
8109 vsa.fSearchVal = GetCellValue(aAdr, aCell);
8110 }
8111 else
8112 {
8113 vsa.isStringSearch = true;
8114 GetCellString(vsa.sSearchStr, aCell);
8115 }
8116 }
8117 break;
8118
8119 case svExternalSingleRef:
8120 {
8121 ScExternalRefCache::TokenRef pToken;
8122 PopExternalSingleRef(pToken);
8123 if (nGlobalError != FormulaError::NONE)
8124 {
8125 PushError( nGlobalError);
8126 return;
8127 }
8128 if (pToken->GetType() == svDouble)
8129 {
8130 vsa.isStringSearch = false;
8131 vsa.fSearchVal = pToken->GetDouble();
8132 }
8133 else
8134 {
8135 vsa.isStringSearch = true;
8136 vsa.sSearchStr = pToken->GetString();
8137 }
8138 }
8139 break;
8140
8141 case svExternalDoubleRef:
8142 case svMatrix :
8143 {
8144 ScMatValType nType = GetDoubleOrStringFromMatrix(
8145 vsa.fSearchVal, vsa.sSearchStr);
8146 vsa.isStringSearch = ScMatrix::IsNonValueType(nType);
8147 }
8148 break;
8149
8150 default:
8151 {
8152 PushIllegalParameter();
8153 return;
8154 }
8155 }
8156 }
8157
8158 // start search
8159 if ( SearchVectorForValue( vsa ) )
8160 {
8161 // found, output result
8162 assert( vsa.bVLookup ? ( o3tl::make_unsigned(vsa.nIndex) < nrR ) :
8163 ( o3tl::make_unsigned(vsa.nIndex) < nrC ) );
8164 SCSIZE nX;
8165 SCSIZE nY;
8166 SCSIZE nResCols;
8167 SCSIZE nResRows;
8168 if ( vsa.bVLookup )
8169 {
8170 nX = static_cast<SCSIZE>(0);
8171 nY = vsa.nIndex;
8172 nResCols = nrC;
8173 nResRows = 1;
8174 }
8175 else
8176 {
8177 nX = vsa.nIndex;
8178 nY = static_cast<SCSIZE>(0);
8179 nResCols = 1;
8180 nResRows = nrR;
8181 }
8182 // if result has more than one row or column push double ref or matrix, else push single ref
8183 if ( nResCols > 1 || nResRows > 1 )
8184 {
8185 if (prMat)
8186 {
8187 // result is matrix, make / fill matrix with output and push that
8188 ScMatrixRef pResMat = GetNewMat(nResCols, nResRows, /*bEmpty*/true);
8189 if (pResMat)
8190 {
8191 for (SCSIZE i = 0; i < nResCols; i++)
8192 {
8193 for (SCSIZE j = 0; j < nResRows; j++)
8194 {
8195 SCSIZE ri;
8196 SCSIZE rj;
8197 if (vsa.bVLookup)
8198 {
8199 ri = nX + i;
8200 rj = nY;
8201 }
8202 else
8203 {
8204 ri = nX;
8205 rj = nY + j;
8206 }
8207 if (prMat->IsEmptyCell(ri, rj))
8208 pResMat->PutEmpty(i, j);
8209 else if (prMat->IsStringOrEmpty(ri, rj))
8210 pResMat->PutString(prMat->GetString(ri, rj), i, j);
8211 else
8212 pResMat->PutDouble(prMat->GetDouble(ri, rj), i, j);
8213 }
8214 }
8215 PushMatrix(pResMat);
8216 }
8217 else
8218 {
8219 PushIllegalParameter();
8220 return;
8221 }
8222 }
8223 else
8224 {
8225 // result is a double ref
8226 PushDoubleRef(nSearchCol1 + nX, nSearchRow1 + nY, nSearchTab1,
8227 nSearchCol1 + (nResCols - 1) + nX, nSearchRow1 + (nResRows - 1) + nY, nSearchTab1);
8228 }
8229 }
8230 else
8231 {
8232 // result is a single ref
8233 PushSingleRef(nSearchCol1 + nX, nSearchRow1 + nY, nSearchTab1);
8234 }
8235 }
8236 else
8237 {
8238 if ( vsa.isResultNA )
8239 {
8240 if ( xNotFound && ( xNotFound->GetType() != svMissing ) )
8241 {
8242 nGlobalError = nFirstMatchError;
8243 PushTokenRef(xNotFound);
8244 }
8245 else
8246 PushNA();
8247 }
8248 }
8249 }
8250
8251 void ScInterpreter::ScFilter()
8252 {
8253 sal_uInt8 nParamCount = GetByte();
8254 if (!MustHaveParamCount(nParamCount, 2, 3))
8255 return;
8256
8257 // Optional 3th argument to set the value to return if all values
8258 // in the included array are empty (filter returns nothing)
8259 formula::FormulaConstTokenRef xNotFound;
8260 if (nParamCount == 3 && GetStackType() != svEmptyCell)
8261 xNotFound = PopToken();
8262
8263 SCCOL nCondResultColEnd = 0;
8264 SCROW nCondResultRowEnd = 0;
8265 ScMatrixRef pCondResultMatrix = nullptr;
8266 std::vector<double> aResValues;
8267 size_t nMatch = 0;
8268 // take 2nd argument criteria bool array
8269 switch ( GetStackType() )
8270 {
8271 case svMatrix :
8272 case svExternalDoubleRef:
8273 case svExternalSingleRef:
8274 case svDoubleRef:
8275 case svSingleRef:
8276 {
8277 pCondResultMatrix = GetMatrix();
8278 if (!pCondResultMatrix)
8279 {
8280 PushError(FormulaError::IllegalParameter);
8281 return;
8282 }
8283 SCSIZE nC, nR;
8284 pCondResultMatrix->GetDimensions(nC, nR);
8285 nCondResultColEnd = static_cast<SCCOL>(nC - 1);
8286 nCondResultRowEnd = static_cast<SCROW>(nR - 1);
8287
8288 // only 1 dimension of filtering allowed (also in excel)
8289 if (nCondResultColEnd > 0 && nCondResultRowEnd > 0)
8290 {
8291 PushError(FormulaError::NoValue);
8292 return;
8293 }
8294
8295 // result matrix is filled with boolean values.
8296 pCondResultMatrix->GetDoubleArray(aResValues);
8297
8298 FormulaError nError = FormulaError::NONE;
8299 auto matchNum = [&nMatch, &nError](double i) {
8300 nError = GetDoubleErrorValue(i);
8301 if (nError != FormulaError::NONE)
8302 {
8303 return true;
8304 }
8305 else
8306 {
8307 if (i > 0)
8308 nMatch++;
8309 return false;
8310 }
8311 };
8312
8313 if (auto it = std::find_if(aResValues.begin(), aResValues.end(), matchNum); it != aResValues.end())
8314 {
8315 PushError(nError);
8316 return;
8317 }
8318 }
8319 break;
8320
8321 default:
8322 {
8323 PushIllegalParameter();
8324 return;
8325 }
8326 }
8327
8328 // bail out, no need to evaluate other arguments
8329 if (nGlobalError != FormulaError::NONE)
8330 {
8331 PushError(nGlobalError);
8332 return;
8333 }
8334
8335 SCCOL nQueryCol1 = 0;
8336 SCROW nQueryRow1 = 0;
8337 SCCOL nQueryCol2 = 0;
8338 SCROW nQueryRow2 = 0;
8339 ScMatrixRef pQueryMatrix = nullptr;
8340 // take 1st argument range
8341 switch ( GetStackType() )
8342 {
8343 case svSingleRef:
8344 case svDoubleRef:
8345 case svMatrix:
8346 case svExternalSingleRef:
8347 case svExternalDoubleRef:
8348 {
8349 pQueryMatrix = GetMatrix();
8350 if (!pQueryMatrix)
8351 {
8352 PushError( FormulaError::IllegalParameter);
8353 return;
8354 }
8355 SCSIZE nC, nR;
8356 pQueryMatrix->GetDimensions( nC, nR);
8357 nQueryCol2 = static_cast<SCCOL>(nC - 1);
8358 nQueryRow2 = static_cast<SCROW>(nR - 1);
8359 }
8360 break;
8361 default:
8362 PushError( FormulaError::IllegalParameter);
8363 return;
8364 }
8365
8366 // bail out, no need to set a matrix if we have no result
8367 if (!nMatch)
8368 {
8369 if (xNotFound && (xNotFound->GetType() != svMissing))
8370 PushTokenRef(xNotFound);
8371 else
8372 PushError(FormulaError::NestedArray);
8373 return;
8374 }
8375
8376 SCSIZE nResPos = 0;
8377 ScMatrixRef pResMat = nullptr;
8378 if (nQueryCol2 == nCondResultColEnd && nCondResultColEnd > 0)
8379 {
8380 pResMat = GetNewMat(nMatch, nQueryRow2 + 1 , /*bEmpty*/true);
8381 for (SCROW iR = nQueryRow1; iR <= nQueryRow2; iR++)
8382 {
8383 for (size_t iC = 0; iC < aResValues.size(); iC++)
8384 {
8385 if (aResValues[iC] > 0)
8386 {
8387 if (pQueryMatrix->IsEmptyCell(iC, iR))
8388 pResMat->PutEmptyTrans(nResPos++);
8389 else if (pQueryMatrix->IsStringOrEmpty(iC, iR))
8390 pResMat->PutStringTrans(pQueryMatrix->GetString(iC, iR), nResPos++);
8391 else
8392 pResMat->PutDoubleTrans(pQueryMatrix->GetDouble(iC, iR), nResPos++);
8393 }
8394 }
8395 }
8396 }
8397 else if (nQueryRow2 == nCondResultRowEnd && nCondResultRowEnd > 0)
8398 {
8399 pResMat = GetNewMat(nQueryCol2 + 1, nMatch, /*bEmpty*/true);
8400 for (SCCOL iC = nQueryCol1; iC <= nQueryCol2; iC++)
8401 {
8402 for (size_t iR = 0; iR < aResValues.size(); iR++)
8403 {
8404 if (aResValues[iR] > 0)
8405 {
8406 if (pQueryMatrix->IsEmptyCell(iC, iR))
8407 pResMat->PutEmpty(nResPos++);
8408 else if (pQueryMatrix->IsStringOrEmpty(iC, iR))
8409 pResMat->PutString(pQueryMatrix->GetString(iC, iR), nResPos++);
8410 else
8411 pResMat->PutDouble(pQueryMatrix->GetDouble(iC, iR), nResPos++);
8412 }
8413 }
8414 }
8415 }
8416 else
8417 {
8418 PushError(FormulaError::IllegalParameter);
8419 return;
8420 }
8421
8422 if (pResMat)
8423 PushMatrix(pResMat);
8424 else
8425 PushError(FormulaError::NestedArray);
8426 }
8427
8428 void ScInterpreter::ScSort()
8429 {
8430 sal_uInt8 nParamCount = GetByte();
8431 if (!MustHaveParamCount(nParamCount, 1, 4))
8432 return;
8433
8434 // Create sort data
8435 ScSortParam aSortData;
8436
8437 // 4th argument optional
8438 aSortData.bByRow = true; // default: By_Col = false --> bByRow = true
8439 if (nParamCount == 4)
8440 aSortData.bByRow = !GetBool();
8441
8442 // 3rd argument optional
8443 std::vector<double> aSortOrderValues{ 1.0 }; // default: 1 = asc, -1 = desc
8444 if (nParamCount >= 3)
8445 {
8446 bool bMissing = IsMissing();
8447 ScMatrixRef pSortOrder = GetMatrix();
8448 if (!bMissing)
8449 {
8450 aSortOrderValues.clear();
8451 pSortOrder->GetDoubleArray(aSortOrderValues);
8452 for (const double& sortOrder : aSortOrderValues)
8453 {
8454 if (sortOrder != 1.0 && sortOrder != -1.0)
8455 {
8456 PushIllegalParameter();
8457 return;
8458 }
8459 }
8460 }
8461 }
8462
8463 // 2nd argument optional
8464 std::vector<double> aSortIndexValues{ 0.0 }; // default: first column or row
8465 if (nParamCount >= 2)
8466 {
8467 bool bMissing = IsMissing();
8468 ScMatrixRef pSortIndex = GetMatrix();
8469 if (!bMissing)
8470 {
8471 aSortIndexValues.clear();
8472 pSortIndex->GetDoubleArray(aSortIndexValues);
8473 for (double& sortIndex : aSortIndexValues)
8474 {
8475 if (sortIndex < 1)
8476 {
8477 PushIllegalParameter();
8478 return;
8479 }
8480 else
8481 sortIndex--;
8482 }
8483 }
8484 }
8485
8486 if (aSortIndexValues.size() != aSortOrderValues.size() && aSortOrderValues.size() > 1)
8487 {
8488 PushIllegalParameter();
8489 return;
8490 }
8491
8492 // 1st argument is vector to be sorted
8493 SCSIZE nsC = 0, nsR = 0;
8494 ScMatrixRef pMatSrc = nullptr;
8495 switch ( GetStackType() )
8496 {
8497 case svSingleRef:
8498 PopSingleRef(aSortData.nCol1, aSortData.nRow1, aSortData.nSourceTab);
8499 aSortData.nCol2 = aSortData.nCol1;
8500 aSortData.nRow2 = aSortData.nRow1;
8501 nsC = aSortData.nCol2 - aSortData.nCol1 + 1;
8502 nsR = aSortData.nRow2 - aSortData.nRow1 + 1;
8503 break;
8504 case svDoubleRef:
8505 {
8506 SCTAB nTab2 = 0;
8507 PopDoubleRef(aSortData.nCol1, aSortData.nRow1, aSortData.nSourceTab, aSortData.nCol2, aSortData.nRow2, nTab2);
8508 if (aSortData.nSourceTab != nTab2)
8509 {
8510 PushIllegalParameter();
8511 return;
8512 }
8513 nsC = aSortData.nCol2 - aSortData.nCol1 + 1;
8514 nsR = aSortData.nRow2 - aSortData.nRow1 + 1;
8515 }
8516 break;
8517 case svMatrix:
8518 case svExternalSingleRef:
8519 case svExternalDoubleRef:
8520 {
8521 pMatSrc = GetMatrix();
8522 if (!pMatSrc)
8523 {
8524 PushIllegalParameter();
8525 return;
8526 }
8527 pMatSrc->GetDimensions(nsC, nsR);
8528 aSortData.nCol2 = nsC - 1; // aSortData.nCol1 = 0
8529 aSortData.nRow2 = nsR - 1; // aSortData.nRow1 = 0
8530 }
8531 break;
8532
8533 default:
8534 PushIllegalParameter();
8535 return;
8536 }
8537
8538 aSortData.maKeyState.resize(aSortIndexValues.size());
8539 for (size_t i = 0; i < aSortIndexValues.size(); i++)
8540 {
8541 SCSIZE fIndex = static_cast<SCSIZE>(double_to_int32(aSortIndexValues[i]));
8542 if ((aSortData.bByRow && fIndex + 1 > nsC) || (!aSortData.bByRow && fIndex + 1 > nsR))
8543 {
8544 PushIllegalParameter();
8545 return;
8546 }
8547
8548 aSortData.maKeyState[i].bDoSort = true;
8549 aSortData.maKeyState[i].nField = (aSortData.bByRow ? aSortData.nCol1 : aSortData.nRow1) + fIndex;
8550
8551 if (aSortIndexValues.size() == aSortOrderValues.size())
8552 aSortData.maKeyState[i].bAscending = (aSortOrderValues[i] == 1.0);
8553 else
8554 aSortData.maKeyState[i].bAscending = (aSortOrderValues[0] == 1.0);
8555 }
8556
8557 // sorting...
8558 std::vector<SCCOLROW> aOrderIndices = GetSortOrder(aSortData, pMatSrc);
8559 // create sorted matrix
8560 ScMatrixRef pResMat = CreateSortedMatrix(aSortData, pMatSrc,
8561 ScRange(aSortData.nCol1, aSortData.nRow1, aSortData.nSourceTab,
8562 aSortData.nCol2, aSortData.nRow2, aSortData.nSourceTab),
8563 aOrderIndices, nsC, nsR);
8564
8565 if (pResMat)
8566 PushMatrix(pResMat);
8567 else
8568 PushIllegalParameter();
8569 }
8570
8571 void ScInterpreter::ScSortBy()
8572 {
8573 sal_uInt8 nParamCount = GetByte();
8574
8575 if (nParamCount < 2/*|| (nParamCount % 2 != 1)*/)
8576 {
8577 PushError(FormulaError::ParameterExpected);
8578 return;
8579 }
8580
8581 sal_uInt8 nSortCount = nParamCount / 2;
8582
8583 ScSortParam aSortData;
8584 aSortData.maKeyState.resize(nSortCount);
8585
8586 // 127th, ..., 3rd and 2nd argument: sort by range/array and sort orders pair
8587 sal_uInt8 nSortBy = nSortCount;
8588 ScMatrixRef pFullMatSortBy = nullptr;
8589 while (nSortBy-- > 0 && nGlobalError == FormulaError::NONE)
8590 {
8591 // 3rd argument sort_order optional: default ascending
8592 if (nParamCount >= 3 && (nParamCount % 2 == 1))
8593 {
8594 sal_Int8 nSortOrder = static_cast<sal_Int8>(GetInt32WithDefault(1));
8595 if (nSortOrder != 1 && nSortOrder != -1)
8596 {
8597 PushIllegalParameter();
8598 return;
8599 }
8600 aSortData.maKeyState[nSortBy].bAscending = (nSortOrder == 1);
8601 nParamCount--;
8602 }
8603
8604 // 2nd argument: take sort by ranges
8605 ScMatrixRef pMatSortBy = nullptr;
8606 SCSIZE nbyC = 0, nbyR = 0;
8607 switch (GetStackType())
8608 {
8609 case svSingleRef:
8610 case svDoubleRef:
8611 case svMatrix:
8612 case svExternalSingleRef:
8613 case svExternalDoubleRef:
8614 {
8615 if (nSortCount == 1)
8616 {
8617 pFullMatSortBy = GetMatrix();
8618 if (!pFullMatSortBy)
8619 {
8620 PushIllegalParameter();
8621 return;
8622 }
8623 pFullMatSortBy->GetDimensions(nbyC, nbyR);
8624 }
8625 else
8626 {
8627 pMatSortBy = GetMatrix();
8628 if (!pMatSortBy)
8629 {
8630 PushIllegalParameter();
8631 return;
8632 }
8633 pMatSortBy->GetDimensions(nbyC, nbyR);
8634 }
8635
8636 // last->first (backward) sortby array
8637 if (nSortBy == nSortCount - 1)
8638 {
8639 if (nbyC == 1 && nbyR > 1)
8640 aSortData.bByRow = true;
8641 else if (nbyR == 1 && nbyC > 1)
8642 aSortData.bByRow = false;
8643 else
8644 {
8645 PushIllegalParameter();
8646 return;
8647 }
8648
8649 if (nSortCount > 1)
8650 {
8651 pFullMatSortBy = GetNewMat(aSortData.bByRow ? (nbyC * nSortCount) : nbyC,
8652 aSortData.bByRow ? nbyR : (nbyR * nSortCount), /*bEmpty*/true);
8653 }
8654 }
8655 }
8656 break;
8657
8658 default:
8659 PushIllegalParameter();
8660 return;
8661 }
8662
8663 // ..., penultimate sortby arrays
8664 if (nSortCount > 1 && nSortBy <= nSortCount - 1)
8665 {
8666 SCSIZE nCheckCol = 0, nCheckRow = 0;
8667 pFullMatSortBy->GetDimensions(nCheckCol, nCheckRow);
8668 if ((aSortData.bByRow && nbyR == nCheckRow && nbyC == 1) ||
8669 (!aSortData.bByRow && nbyC == nCheckCol && nbyR == 1))
8670 {
8671 for (SCSIZE ci = 0; ci < nbyC; ci++)//col
8672 {
8673 for (SCSIZE rj = 0; rj < nbyR; rj++)//row
8674 {
8675 if (pMatSortBy->IsEmptyCell(ci, rj))
8676 {
8677 if (aSortData.bByRow)
8678 pFullMatSortBy->PutEmpty(ci + nSortBy, rj);
8679 else
8680 pFullMatSortBy->PutEmpty(ci, rj + nSortBy);
8681 }
8682 else if (pMatSortBy->IsStringOrEmpty(ci, rj))
8683 {
8684 if (aSortData.bByRow)
8685 pFullMatSortBy->PutString(pMatSortBy->GetString(ci, rj), ci + nSortBy, rj);
8686 else
8687 pFullMatSortBy->PutString(pMatSortBy->GetString(ci, rj), ci, rj + nSortBy);
8688 }
8689 else
8690 {
8691 if (aSortData.bByRow)
8692 pFullMatSortBy->PutDouble(pMatSortBy->GetDouble(ci, rj), ci + nSortBy, rj);
8693 else
8694 pFullMatSortBy->PutDouble(pMatSortBy->GetDouble(ci, rj), ci, rj + nSortBy);
8695 }
8696 }
8697 }
8698 }
8699 else
8700 {
8701 PushIllegalParameter();
8702 return;
8703 }
8704 }
8705
8706 aSortData.maKeyState[nSortBy].bDoSort = true;
8707 aSortData.maKeyState[nSortBy].nField = nSortBy;
8708
8709 nParamCount--;
8710 }
8711
8712 // 1st argument is the range/array to be sorted
8713 SCSIZE nsC = 0, nsR = 0;
8714 SCCOL nSortCol1 = 0, nSortCol2 = 0;
8715 SCROW nSortRow1 = 0, nSortRow2 = 0;
8716 SCTAB nSortTab1 = 0, nSortTab2 = 0;
8717 ScMatrixRef pMatSrc = nullptr;
8718 switch ( GetStackType() )
8719 {
8720 case svSingleRef:
8721 PopSingleRef(nSortCol1, nSortRow1, nSortTab1);
8722 nSortCol2 = nSortCol1;
8723 nSortRow2 = nSortRow1;
8724 nsC = nSortCol2 - nSortCol1 + 1;
8725 nsR = nSortRow2 - nSortRow1 + 1;
8726 break;
8727 case svDoubleRef:
8728 {
8729 PopDoubleRef(nSortCol1, nSortRow1, nSortTab1, nSortCol2, nSortRow2, nSortTab2);
8730 if (nSortTab1 != nSortTab2)
8731 {
8732 PushIllegalParameter();
8733 return;
8734 }
8735 nsC = nSortCol2 - nSortCol1 + 1;
8736 nsR = nSortRow2 - nSortRow1 + 1;
8737 }
8738 break;
8739 case svMatrix:
8740 case svExternalSingleRef:
8741 case svExternalDoubleRef:
8742 {
8743 pMatSrc = GetMatrix();
8744 if (!pMatSrc)
8745 {
8746 PushIllegalParameter();
8747 return;
8748 }
8749 pMatSrc->GetDimensions(nsC, nsR);
8750 nSortCol2 = nsC - 1; // nSortCol1 = 0
8751 nSortRow2 = nsR - 1; // nSortRow1 = 0
8752 }
8753 break;
8754
8755 default:
8756 PushIllegalParameter();
8757 return;
8758 }
8759
8760 SCSIZE nCheckMatrixCol = 0, nCheckMatrixRow = 0;
8761 pFullMatSortBy->GetDimensions(nCheckMatrixCol, nCheckMatrixRow);
8762 if (nGlobalError != FormulaError::NONE)
8763 {
8764 PushError(nGlobalError);
8765 return;
8766 }
8767 else if ((aSortData.bByRow && nsR != nCheckMatrixRow) ||
8768 (!aSortData.bByRow && nsC != nCheckMatrixCol))
8769 {
8770 PushIllegalParameter();
8771 return;
8772 }
8773 else
8774 {
8775 aSortData.nCol2 = nCheckMatrixCol - 1;
8776 aSortData.nRow2 = nCheckMatrixRow - 1;
8777 }
8778
8779 // sorting...
8780 std::vector<SCCOLROW> aOrderIndices = GetSortOrder(aSortData, pFullMatSortBy);
8781 // create sorted matrix
8782 ScMatrixRef pResMat = CreateSortedMatrix(aSortData, pMatSrc,
8783 ScRange(nSortCol1, nSortRow1, nSortTab1, nSortCol2, nSortRow2, nSortTab2),
8784 aOrderIndices, nsC, nsR);
8785
8786 if (pResMat)
8787 PushMatrix(pResMat);
8788 else
8789 PushIllegalParameter();
8790 }
8791
8792 void ScInterpreter::ScUnique()
8793 {
8794 sal_uInt8 nParamCount = GetByte();
8795 if (!MustHaveParamCount(nParamCount, 1, 3))
8796 return;
8797
8798 // 3rd argument optional - Exactly_once: default FALSE
8799 bool bExactly_once = false;
8800 if (nParamCount == 3)
8801 bExactly_once = GetBoolWithDefault(false);
8802
8803 // 2nd argument optional - default: By_Col = false --> bByRow = true
8804 bool bByRow = true;
8805 if (nParamCount >= 2)
8806 bByRow = !GetBoolWithDefault(false);
8807
8808 // 1st argument: take unique search range
8809 ScMatrixRef pMatSource = nullptr;
8810 SCSIZE nsC = 0, nsR = 0;
8811 switch (GetStackType())
8812 {
8813 case svSingleRef:
8814 case svDoubleRef:
8815 case svMatrix:
8816 case svExternalSingleRef:
8817 case svExternalDoubleRef:
8818 {
8819 pMatSource = GetMatrix();
8820 if (!pMatSource)
8821 {
8822 PushIllegalParameter();
8823 return;
8824 }
8825
8826 pMatSource->GetDimensions(nsC, nsR);
8827 }
8828 break;
8829
8830 default:
8831 PushIllegalParameter();
8832 return;
8833 }
8834
8835 if (nGlobalError != FormulaError::NONE || nsC < 1 || nsR < 1)
8836 {
8837 PushIllegalArgument();
8838 return;
8839 }
8840
8841 // Create unique dataset
8842 std::unordered_set<OUString> aStrSet;
8843 std::vector<std::pair<SCSIZE, OUString>> aResPos;
8844 SCSIZE nOut = bByRow ? nsR : nsC;
8845 SCSIZE nIn = bByRow ? nsC : nsR;
8846
8847 for (SCSIZE i = 0; i < nOut; i++)
8848 {
8849 OUString aStr;
8850 for (SCSIZE j = 0; j < nIn; j++)
8851 {
8852 OUString aCellStr = bByRow ? pMatSource->GetString(mrContext, j, i).getString() :
8853 pMatSource->GetString(mrContext, i, j).getString();
8854 aStr += aCellStr + u"\x0001";
8855 }
8856
8857 if (aStrSet.insert(aStr).second) // unique if inserted
8858 {
8859 aResPos.emplace_back(std::make_pair(i, aStr));
8860 }
8861 else
8862 {
8863 if (bExactly_once)
8864 {
8865 auto it = std::find_if(aResPos.begin(), aResPos.end(),
8866 [&aStr](const std::pair<SCSIZE, OUString>& aRes)
8867 {
8868 return aRes.second.equals(aStr);
8869 }
8870 );
8871 if (it != aResPos.end())
8872 aResPos.erase(it);
8873 }
8874 }
8875 }
8876 // No result
8877 if (aResPos.size() == 0)
8878 {
8879 if (nGlobalError != FormulaError::NONE)
8880 {
8881 PushIllegalArgument();
8882 }
8883 else
8884 {
8885 PushNA();
8886 }
8887 return;
8888 }
8889 // fill result matrix with unique values
8890 ScMatrixRef pResMat = bByRow ? GetNewMat(nsC, aResPos.size(), /*bEmpty*/true) :
8891 GetNewMat(aResPos.size(), nsR, /*bEmpty*/true);
8892 for (SCSIZE iPos = 0; iPos < aResPos.size(); iPos++)
8893 {
8894 if (bByRow)
8895 {
8896 for (SCSIZE col = 0; col < nsC; col++)
8897 {
8898 if (pMatSource->IsEmptyCell(col, aResPos[iPos].first))
8899 {
8900 pResMat->PutEmpty(col, iPos);
8901 }
8902 else if (!pMatSource->IsStringOrEmpty(col, aResPos[iPos].first))
8903 {
8904 pResMat->PutDouble(pMatSource->GetDouble(col, aResPos[iPos].first), col, iPos);
8905 }
8906 else
8907 {
8908 pResMat->PutString(pMatSource->GetString(col, aResPos[iPos].first), col, iPos);
8909 }
8910 }
8911 }
8912 else
8913 {
8914 for (SCSIZE row = 0; row < nsR; row++)
8915 {
8916 if (pMatSource->IsEmptyCell(aResPos[iPos].first, row))
8917 {
8918 pResMat->PutEmpty(iPos, row);
8919 }
8920 else if (!pMatSource->IsStringOrEmpty(aResPos[iPos].first, row))
8921 {
8922 pResMat->PutDouble(pMatSource->GetDouble(aResPos[iPos].first, row), iPos, row);
8923 }
8924 else
8925 {
8926 pResMat->PutString(pMatSource->GetString(aResPos[iPos].first, row), iPos, row);
8927 }
8928 }
8929 }
8930 }
8931
8932 if (!pResMat)
8933 {
8934 PushIllegalArgument();
8935 }
8936 else
8937 {
8938 PushMatrix(pResMat);
8939 }
8940 }
8941
8942 void ScInterpreter::getTokensAtParameter( std::unique_ptr<ScTokenArray>& pTokens, short nPos )
8943 {
8944 sal_uInt16 nOpen = 0;
8945 sal_uInt16 nSepCount = 0;
8946 formula::FormulaTokenArrayPlainIterator aIter(*pArr);
8947 formula::FormulaToken* t = aIter.First();
8948 for (t = aIter.NextNoSpaces(); t; t = aIter.NextNoSpaces())
8949 {
8950 OpCode aOpCode = t->GetOpCode();
8951 formula::StackVar aIntType = t->GetType();
8952 if ((aOpCode == ocOpen || aOpCode == ocArrayOpen || aOpCode == ocTableRefOpen) && aIntType == formula::StackVar::svSep)
8953 nOpen++;
8954 else if ((aOpCode == ocClose || aOpCode == ocArrayClose || aOpCode == ocTableRefClose) && aIntType == formula::StackVar::svSep)
8955 nOpen--;
8956 else if (aOpCode == ocSep && aIntType == formula::StackVar::svSep && nOpen == 1)
8957 {
8958 nSepCount++;
8959 continue;
8960 }
8961
8962 if (nSepCount == nPos && nOpen > 0)
8963 {
8964 pTokens->AddToken(*t->Clone());
8965 }
8966 }
8967 }
8968
8969 void ScInterpreter::replaceNamesToResult( const std::unordered_map<OUString, formula::FormulaToken*> nResultIndexes,
8970 std::unique_ptr<ScTokenArray>& pTokens )
8971 {
8972 formula::FormulaTokenArrayPlainIterator aIterResult(*pTokens);
8973 for (FormulaToken* t = aIterResult.GetNextStringName(); t; t = aIterResult.GetNextStringName())
8974 {
8975 auto iRes = nResultIndexes.find(t->GetString().getString());
8976 if (iRes != nResultIndexes.end())
8977 pTokens->ReplaceToken(aIterResult.GetIndex() - 1, iRes->second->Clone(),
8978 FormulaTokenArray::ReplaceMode::CODE_ONLY);
8979 }
8980 }
8981
8982 void ScInterpreter::ScLet()
8983 {
8984 const short* pJump = pCur->GetJump();
8985 short nJumpCount = pJump[0];
8986 short nOrgJumpCount = nJumpCount;
8987
8988 if (nJumpCount < 3 || (nJumpCount % 2 != 1))
8989 {
8990 PushError(FormulaError::ParameterExpected);
8991 aCode.Jump(pJump[nOrgJumpCount], pJump[nOrgJumpCount]);
8992 return;
8993 }
8994
8995 OUString aStrName;
8996 std::unordered_map<OUString, formula::FormulaToken*> nResultIndexes;
8997 formula::FormulaTokenArrayPlainIterator aIter(*pArr);
8998 unique_ptr<ScTokenArray> pValueTokens(new ScTokenArray(mrDoc));
8999
9000 // name and function pairs parameter
9001 while (nJumpCount > 1)
9002 {
9003 if (nJumpCount == nOrgJumpCount)
9004 {
9005 aStrName = GetString().getString();
9006 }
9007 else if ((nOrgJumpCount - nJumpCount + 1) % 2 == 1)
9008 {
9009 aIter.Jump(pJump[static_cast<short>(nOrgJumpCount - nJumpCount + 1)] - 1);
9010 FormulaToken* t = aIter.NextRPN();
9011 aStrName = t->GetString().getString();
9012 }
9013 else
9014 {
9015 PushError(FormulaError::ParameterExpected);
9016 aCode.Jump(pJump[nOrgJumpCount], pJump[nOrgJumpCount]);
9017 return;
9018 }
9019 nJumpCount--;
9020
9021 // get value tokens
9022 getTokensAtParameter(pValueTokens, nOrgJumpCount - nJumpCount);
9023 nJumpCount--;
9024
9025 // replace names with result tokens
9026 replaceNamesToResult(nResultIndexes, pValueTokens);
9027
9028 // calculate the inner results unless we already have a push result token
9029 if (pValueTokens->GetLen() == 1 && pValueTokens->GetArray()[0]->GetOpCode() == ocPush)
9030 {
9031 if (!nResultIndexes.insert(std::make_pair(aStrName, pValueTokens->GetArray()[0]->Clone())).second)
9032 {
9033 PushIllegalParameter();
9034 aCode.Jump(pJump[nOrgJumpCount], pJump[nOrgJumpCount]);
9035 return;
9036 }
9037 }
9038 else
9039 {
9040 ScCompiler aComp(mrDoc, aPos, *pValueTokens, mrDoc.GetGrammar(), false, false, &mrContext);
9041 aComp.CompileTokenArray();
9042 ScInterpreter aInt(mrDoc.GetFormulaCell(aPos), mrDoc, mrContext, aPos, *pValueTokens);
9043 sfx2::LinkManager aNewLinkMgr(mrDoc.GetDocumentShell());
9044 aInt.SetLinkManager(&aNewLinkMgr);
9045 formula::StackVar aIntType = aInt.Interpret();
9046
9047 if (aIntType == formula::svMatrixCell)
9048 {
9049 ScConstMatrixRef xMat(aInt.GetResultToken()->GetMatrix());
9050 if (!nResultIndexes.insert(std::make_pair(aStrName, new ScMatrixToken(xMat->Clone()))).second)
9051 {
9052 PushIllegalParameter();
9053 aCode.Jump(pJump[nOrgJumpCount], pJump[nOrgJumpCount]);
9054 return;
9055 }
9056 }
9057 else
9058 {
9059 FormulaConstTokenRef xTok(aInt.GetResultToken());
9060 if (!nResultIndexes.insert(std::make_pair(aStrName, xTok->Clone())).second)
9061 {
9062 PushIllegalParameter();
9063 aCode.Jump(pJump[nOrgJumpCount], pJump[nOrgJumpCount]);
9064 return;
9065 }
9066 }
9067 }
9068 pValueTokens->Clear();
9069 }
9070
9071 // last parameter: calculation
9072 getTokensAtParameter(pValueTokens, nOrgJumpCount - nJumpCount);
9073 nJumpCount--;
9074
9075 // replace names with result tokens
9076 replaceNamesToResult(nResultIndexes, pValueTokens);
9077
9078 // calculate the final result
9079 ScCompiler aComp(mrDoc, aPos, *pValueTokens, mrDoc.GetGrammar(), false, false, &mrContext);
9080 aComp.CompileTokenArray();
9081 ScInterpreter aInt(mrDoc.GetFormulaCell(aPos), mrDoc, mrContext, aPos, *pValueTokens);
9082 sfx2::LinkManager aNewLinkMgr(mrDoc.GetDocumentShell());
9083 aInt.SetLinkManager(&aNewLinkMgr);
9084 formula::StackVar aIntType = aInt.Interpret();
9085
9086 if (aIntType == formula::svMatrixCell)
9087 {
9088 ScConstMatrixRef xMat(aInt.GetResultToken()->GetMatrix());
9089 PushTokenRef(new ScMatrixToken(xMat->Clone()));
9090 }
9091 else
9092 {
9093 formula::FormulaConstTokenRef xLambdaResult(aInt.GetResultToken());
9094 if (xLambdaResult)
9095 {
9096 nGlobalError = xLambdaResult->GetError();
9097 if (nGlobalError == FormulaError::NONE)
9098 PushTokenRef(xLambdaResult);
9099 else
9100 PushError(nGlobalError);
9101 }
9102 }
9103
9104 pValueTokens.reset();
9105 aCode.Jump(pJump[nOrgJumpCount], pJump[nOrgJumpCount]);
9106 }
9107
9108 void ScInterpreter::ScSubTotal()
9109 {
9110 sal_uInt8 nParamCount = GetByte();
9111 if ( !MustHaveParamCountMinWithStackCheck( nParamCount, 2 ) )
9112 return;
9113
9114 // We must fish the 1st parameter deep from the stack! And push it on top.
9115 const FormulaToken* p = pStack[ sp - nParamCount ];
9116 PushWithoutError( *p );
9117 sal_Int32 nFunc = GetInt32();
9118 mnSubTotalFlags |= SubtotalFlags::IgnoreNestedStAg | SubtotalFlags::IgnoreFiltered;
9119 if (nFunc > 100)
9120 {
9121 // For opcodes 101 through 111, we need to skip hidden cells.
9122 // Other than that these opcodes are identical to 1 through 11.
9123 mnSubTotalFlags |= SubtotalFlags::IgnoreHidden;
9124 nFunc -= 100;
9125 }
9126
9127 if ( nGlobalError != FormulaError::NONE || nFunc < 1 || nFunc > 11 )
9128 PushIllegalArgument(); // simulate return on stack, not SetError(...)
9129 else
9130 {
9131 cPar = nParamCount - 1;
9132 switch( nFunc )
9133 {
9134 case SUBTOTAL_FUNC_AVE : ScAverage(); break;
9135 case SUBTOTAL_FUNC_CNT : ScCount(); break;
9136 case SUBTOTAL_FUNC_CNT2 : ScCount2(); break;
9137 case SUBTOTAL_FUNC_MAX : ScMax(); break;
9138 case SUBTOTAL_FUNC_MIN : ScMin(); break;
9139 case SUBTOTAL_FUNC_PROD : ScProduct(); break;
9140 case SUBTOTAL_FUNC_STD : ScStDev(); break;
9141 case SUBTOTAL_FUNC_STDP : ScStDevP(); break;
9142 case SUBTOTAL_FUNC_SUM : ScSum(); break;
9143 case SUBTOTAL_FUNC_VAR : ScVar(); break;
9144 case SUBTOTAL_FUNC_VARP : ScVarP(); break;
9145 default : PushIllegalArgument(); break;
9146 }
9147 }
9148 mnSubTotalFlags = SubtotalFlags::NONE;
9149 // Get rid of the 1st (fished) parameter.
9150 FormulaConstTokenRef xRef( PopToken());
9151 Pop();
9152 PushTokenRef( xRef);
9153 }
9154
9155 void ScInterpreter::ScAggregate()
9156 {
9157 sal_uInt8 nParamCount = GetByte();
9158 if ( !MustHaveParamCountMinWithStackCheck( nParamCount, 3 ) )
9159 return;
9160
9161 const FormulaError nErr = nGlobalError;
9162 nGlobalError = FormulaError::NONE;
9163
9164 // fish the 1st parameter from the stack and push it on top.
9165 const FormulaToken* p = pStack[ sp - nParamCount ];
9166 PushWithoutError( *p );
9167 sal_Int32 nFunc = GetInt32();
9168 // fish the 2nd parameter from the stack and push it on top.
9169 const FormulaToken* p2 = pStack[ sp - ( nParamCount - 1 ) ];
9170 PushWithoutError( *p2 );
9171 sal_Int32 nOption = GetInt32();
9172
9173 if ( nGlobalError != FormulaError::NONE || nFunc < 1 || nFunc > 19 )
9174 {
9175 nGlobalError = nErr;
9176 PushIllegalArgument();
9177 }
9178 else
9179 {
9180 switch ( nOption)
9181 {
9182 case 0 : // ignore nested SUBTOTAL and AGGREGATE functions
9183 mnSubTotalFlags = SubtotalFlags::IgnoreNestedStAg;
9184 break;
9185 case 1 : // ignore hidden rows, nested SUBTOTAL and AGGREGATE functions
9186 mnSubTotalFlags = SubtotalFlags::IgnoreHidden | SubtotalFlags::IgnoreNestedStAg;
9187 break;
9188 case 2 : // ignore error values, nested SUBTOTAL and AGGREGATE functions
9189 mnSubTotalFlags = SubtotalFlags::IgnoreErrVal | SubtotalFlags::IgnoreNestedStAg;
9190 break;
9191 case 3 : // ignore hidden rows, error values, nested SUBTOTAL and AGGREGATE functions
9192 mnSubTotalFlags = SubtotalFlags::IgnoreHidden | SubtotalFlags::IgnoreErrVal | SubtotalFlags::IgnoreNestedStAg;
9193 break;
9194 case 4 : // ignore nothing
9195 mnSubTotalFlags = SubtotalFlags::NONE;
9196 break;
9197 case 5 : // ignore hidden rows
9198 mnSubTotalFlags = SubtotalFlags::IgnoreHidden ;
9199 break;
9200 case 6 : // ignore error values
9201 mnSubTotalFlags = SubtotalFlags::IgnoreErrVal ;
9202 break;
9203 case 7 : // ignore hidden rows and error values
9204 mnSubTotalFlags = SubtotalFlags::IgnoreHidden | SubtotalFlags::IgnoreErrVal ;
9205 break;
9206 default :
9207 nGlobalError = nErr;
9208 PushIllegalArgument();
9209 return;
9210 }
9211
9212 if ((mnSubTotalFlags & SubtotalFlags::IgnoreErrVal) == SubtotalFlags::NONE)
9213 nGlobalError = nErr;
9214
9215 cPar = nParamCount - 2;
9216 switch ( nFunc )
9217 {
9218 case AGGREGATE_FUNC_AVE : ScAverage(); break;
9219 case AGGREGATE_FUNC_CNT : ScCount(); break;
9220 case AGGREGATE_FUNC_CNT2 : ScCount2(); break;
9221 case AGGREGATE_FUNC_MAX : ScMax(); break;
9222 case AGGREGATE_FUNC_MIN : ScMin(); break;
9223 case AGGREGATE_FUNC_PROD : ScProduct(); break;
9224 case AGGREGATE_FUNC_STD : ScStDev(); break;
9225 case AGGREGATE_FUNC_STDP : ScStDevP(); break;
9226 case AGGREGATE_FUNC_SUM : ScSum(); break;
9227 case AGGREGATE_FUNC_VAR : ScVar(); break;
9228 case AGGREGATE_FUNC_VARP : ScVarP(); break;
9229 case AGGREGATE_FUNC_MEDIAN : ScMedian(); break;
9230 case AGGREGATE_FUNC_MODSNGL : ScModalValue(); break;
9231 case AGGREGATE_FUNC_LARGE : ScLarge(); break;
9232 case AGGREGATE_FUNC_SMALL : ScSmall(); break;
9233 case AGGREGATE_FUNC_PERCINC : ScPercentile( true ); break;
9234 case AGGREGATE_FUNC_QRTINC : ScQuartile( true ); break;
9235 case AGGREGATE_FUNC_PERCEXC : ScPercentile( false ); break;
9236 case AGGREGATE_FUNC_QRTEXC : ScQuartile( false ); break;
9237 default:
9238 nGlobalError = nErr;
9239 PushIllegalArgument();
9240 break;
9241 }
9242 mnSubTotalFlags = SubtotalFlags::NONE;
9243 }
9244 FormulaConstTokenRef xRef( PopToken());
9245 // Get rid of the 1st and 2nd (fished) parameters.
9246 Pop();
9247 Pop();
9248 PushTokenRef( xRef);
9249 }
9250
9251 std::unique_ptr<ScDBQueryParamBase> ScInterpreter::GetDBParams( bool& rMissingField )
9252 {
9253 bool bAllowMissingField = false;
9254 if ( rMissingField )
9255 {
9256 bAllowMissingField = true;
9257 rMissingField = false;
9258 }
9259 if ( GetByte() == 3 )
9260 {
9261 // First, get the query criteria range.
9262 ::std::unique_ptr<ScDBRangeBase> pQueryRef( PopDBDoubleRef() );
9263 if (!pQueryRef)
9264 return nullptr;
9265
9266 bool bByVal = true;
9267 double nVal = 0.0;
9268 svl::SharedString aStr;
9269 ScRange aMissingRange;
9270 bool bRangeFake = false;
9271 switch (GetStackType())
9272 {
9273 case svDouble :
9274 nVal = ::rtl::math::approxFloor( GetDouble() );
9275 if ( bAllowMissingField && nVal == 0.0 )
9276 rMissingField = true; // fake missing parameter
9277 break;
9278 case svString :
9279 bByVal = false;
9280 aStr = GetString();
9281 break;
9282 case svSingleRef :
9283 {
9284 ScAddress aAdr;
9285 PopSingleRef( aAdr );
9286 ScRefCellValue aCell(mrDoc, aAdr);
9287 if (aCell.hasNumeric())
9288 nVal = GetCellValue(aAdr, aCell);
9289 else
9290 {
9291 bByVal = false;
9292 GetCellString(aStr, aCell);
9293 }
9294 }
9295 break;
9296 case svDoubleRef :
9297 if ( bAllowMissingField )
9298 { // fake missing parameter for old SO compatibility
9299 bRangeFake = true;
9300 PopDoubleRef( aMissingRange );
9301 }
9302 else
9303 {
9304 PopError();
9305 SetError( FormulaError::IllegalParameter );
9306 }
9307 break;
9308 case svMissing :
9309 PopError();
9310 if ( bAllowMissingField )
9311 rMissingField = true;
9312 else
9313 SetError( FormulaError::IllegalParameter );
9314 break;
9315 default:
9316 PopError();
9317 SetError( FormulaError::IllegalParameter );
9318 }
9319
9320 if (nGlobalError != FormulaError::NONE)
9321 return nullptr;
9322
9323 unique_ptr<ScDBRangeBase> pDBRef( PopDBDoubleRef() );
9324
9325 if (nGlobalError != FormulaError::NONE || !pDBRef)
9326 return nullptr;
9327
9328 if ( bRangeFake )
9329 {
9330 // range parameter must match entire database range
9331 if (pDBRef->isRangeEqual(aMissingRange))
9332 rMissingField = true;
9333 else
9334 SetError( FormulaError::IllegalParameter );
9335 }
9336
9337 if (nGlobalError != FormulaError::NONE)
9338 return nullptr;
9339
9340 SCCOL nField = pDBRef->getFirstFieldColumn();
9341 if (rMissingField)
9342 ; // special case
9343 else if (bByVal)
9344 nField = pDBRef->findFieldColumn(static_cast<SCCOL>(nVal));
9345 else
9346 {
9347 FormulaError nErr = FormulaError::NONE;
9348 nField = pDBRef->findFieldColumn(aStr.getString(), &nErr);
9349 SetError(nErr);
9350 }
9351
9352 if (!mrDoc.ValidCol(nField))
9353 return nullptr;
9354
9355 unique_ptr<ScDBQueryParamBase> pParam( pDBRef->createQueryParam(pQueryRef.get()) );
9356
9357 if (pParam)
9358 {
9359 // An allowed missing field parameter sets the result field
9360 // to any of the query fields, just to be able to return
9361 // some cell from the iterator.
9362 if ( rMissingField )
9363 nField = static_cast<SCCOL>(pParam->GetEntry(0).nField);
9364 pParam->mnField = nField;
9365
9366 SCSIZE nCount = pParam->GetEntryCount();
9367 for ( SCSIZE i=0; i < nCount; i++ )
9368 {
9369 ScQueryEntry& rEntry = pParam->GetEntry(i);
9370 if (!rEntry.bDoQuery)
9371 break;
9372
9373 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
9374 sal_uInt32 nIndex = 0;
9375 OUString aQueryStr = rItem.maString.getString();
9376 bool bNumber = mrContext.NFIsNumberFormat(
9377 aQueryStr, nIndex, rItem.mfVal);
9378 rItem.meType = bNumber ? ScQueryEntry::ByValue : ScQueryEntry::ByString;
9379
9380 if (!bNumber && pParam->eSearchType == utl::SearchParam::SearchType::Normal)
9381 pParam->eSearchType = DetectSearchType(aQueryStr, mrDoc);
9382 }
9383 return pParam;
9384 }
9385 }
9386 return nullptr;
9387 }
9388
9389 void ScInterpreter::DBIterator( ScIterFunc eFunc )
9390 {
9391 double fRes = 0;
9392 KahanSum fErg = 0;
9393 sal_uLong nCount = 0;
9394 bool bMissingField = false;
9395 unique_ptr<ScDBQueryParamBase> pQueryParam( GetDBParams(bMissingField) );
9396 if (pQueryParam)
9397 {
9398 if (!pQueryParam->IsValidFieldIndex())
9399 {
9400 SetError(FormulaError::NoValue);
9401 return;
9402 }
9403 ScDBQueryDataIterator aValIter(mrDoc, mrContext, std::move(pQueryParam));
9404 ScDBQueryDataIterator::Value aValue;
9405 if ( aValIter.GetFirst(aValue) && aValue.mnError == FormulaError::NONE )
9406 {
9407 switch( eFunc )
9408 {
9409 case ifPRODUCT: fRes = 1; break;
9410 case ifMAX: fRes = -MAXDOUBLE; break;
9411 case ifMIN: fRes = MAXDOUBLE; break;
9412 default: ; // nothing
9413 }
9414
9415 do
9416 {
9417 nCount++;
9418 switch( eFunc )
9419 {
9420 case ifAVERAGE:
9421 case ifSUM:
9422 fErg += aValue.mfValue;
9423 break;
9424 case ifSUMSQ:
9425 fErg += aValue.mfValue * aValue.mfValue;
9426 break;
9427 case ifPRODUCT:
9428 fRes *= aValue.mfValue;
9429 break;
9430 case ifMAX:
9431 if( aValue.mfValue > fRes ) fRes = aValue.mfValue;
9432 break;
9433 case ifMIN:
9434 if( aValue.mfValue < fRes ) fRes = aValue.mfValue;
9435 break;
9436 default: ; // nothing
9437 }
9438 }
9439 while ( aValIter.GetNext(aValue) && aValue.mnError == FormulaError::NONE );
9440 }
9441 SetError(aValue.mnError);
9442 }
9443 else
9444 SetError( FormulaError::IllegalParameter);
9445 switch( eFunc )
9446 {
9447 case ifCOUNT: fRes = nCount; break;
9448 case ifSUM: fRes = fErg.get(); break;
9449 case ifSUMSQ: fRes = fErg.get(); break;
9450 case ifAVERAGE: fRes = div(fErg.get(), nCount); break;
9451 default: ; // nothing
9452 }
9453 PushDouble( fRes );
9454 }
9455
9456 void ScInterpreter::ScDBSum()
9457 {
9458 DBIterator( ifSUM );
9459 }
9460
9461 void ScInterpreter::ScDBCount()
9462 {
9463 bool bMissingField = true;
9464 unique_ptr<ScDBQueryParamBase> pQueryParam( GetDBParams(bMissingField) );
9465 if (pQueryParam)
9466 {
9467 sal_uLong nCount = 0;
9468 if ( bMissingField && pQueryParam->GetType() == ScDBQueryParamBase::INTERNAL )
9469 { // count all matching records
9470 // TODO: currently the QueryIterators only return cell pointers of
9471 // existing cells, so if a query matches an empty cell there's
9472 // nothing returned, and therefore not counted!
9473 // Since this has ever been the case and this code here only came
9474 // into existence to fix #i6899 and it never worked before we'll
9475 // have to live with it until we reimplement the iterators to also
9476 // return empty cells, which would mean to adapt all callers of
9477 // iterators.
9478 ScDBQueryParamInternal* p = static_cast<ScDBQueryParamInternal*>(pQueryParam.get());
9479 p->nCol2 = p->nCol1; // Don't forget to select only one column.
9480 SCTAB nTab = p->nTab;
9481 // ScQueryCellIteratorDirect doesn't make use of ScDBQueryParamBase::mnField,
9482 // so the source range has to be restricted, like before the introduction
9483 // of ScDBQueryParamBase.
9484 p->nCol1 = p->nCol2 = p->mnField;
9485 ScQueryCellIteratorDirect aCellIter(mrDoc, mrContext, nTab, *p, true, false);
9486 if ( aCellIter.GetFirst() )
9487 {
9488 do
9489 {
9490 nCount++;
9491 } while ( aCellIter.GetNext() );
9492 }
9493 }
9494 else
9495 { // count only matching records with a value in the "result" field
9496 if (!pQueryParam->IsValidFieldIndex())
9497 {
9498 SetError(FormulaError::NoValue);
9499 return;
9500 }
9501 ScDBQueryDataIterator aValIter(mrDoc, mrContext, std::move(pQueryParam));
9502 ScDBQueryDataIterator::Value aValue;
9503 if ( aValIter.GetFirst(aValue) && aValue.mnError == FormulaError::NONE )
9504 {
9505 do
9506 {
9507 nCount++;
9508 }
9509 while ( aValIter.GetNext(aValue) && aValue.mnError == FormulaError::NONE );
9510 }
9511 SetError(aValue.mnError);
9512 }
9513 PushDouble( nCount );
9514 }
9515 else
9516 PushIllegalParameter();
9517 }
9518
9519 void ScInterpreter::ScDBCount2()
9520 {
9521 bool bMissingField = true;
9522 unique_ptr<ScDBQueryParamBase> pQueryParam( GetDBParams(bMissingField) );
9523 if (pQueryParam)
9524 {
9525 if (!pQueryParam->IsValidFieldIndex())
9526 {
9527 SetError(FormulaError::NoValue);
9528 return;
9529 }
9530 sal_uLong nCount = 0;
9531 pQueryParam->mbSkipString = false;
9532 ScDBQueryDataIterator aValIter(mrDoc, mrContext, std::move(pQueryParam));
9533 ScDBQueryDataIterator::Value aValue;
9534 if ( aValIter.GetFirst(aValue) && aValue.mnError == FormulaError::NONE )
9535 {
9536 do
9537 {
9538 nCount++;
9539 }
9540 while ( aValIter.GetNext(aValue) && aValue.mnError == FormulaError::NONE );
9541 }
9542 SetError(aValue.mnError);
9543 PushDouble( nCount );
9544 }
9545 else
9546 PushIllegalParameter();
9547 }
9548
9549 void ScInterpreter::ScDBAverage()
9550 {
9551 DBIterator( ifAVERAGE );
9552 }
9553
9554 void ScInterpreter::ScDBMax()
9555 {
9556 DBIterator( ifMAX );
9557 }
9558
9559 void ScInterpreter::ScDBMin()
9560 {
9561 DBIterator( ifMIN );
9562 }
9563
9564 void ScInterpreter::ScDBProduct()
9565 {
9566 DBIterator( ifPRODUCT );
9567 }
9568
9569 void ScInterpreter::GetDBStVarParams( double& rVal, double& rValCount )
9570 {
9571 std::vector<double> values;
9572 KahanSum vSum = 0.0;
9573 KahanSum fSum = 0.0;
9574
9575 rValCount = 0.0;
9576 bool bMissingField = false;
9577 unique_ptr<ScDBQueryParamBase> pQueryParam( GetDBParams(bMissingField) );
9578 if (pQueryParam)
9579 {
9580 if (!pQueryParam->IsValidFieldIndex())
9581 {
9582 SetError(FormulaError::NoValue);
9583 return;
9584 }
9585 ScDBQueryDataIterator aValIter(mrDoc, mrContext, std::move(pQueryParam));
9586 ScDBQueryDataIterator::Value aValue;
9587 if (aValIter.GetFirst(aValue) && aValue.mnError == FormulaError::NONE)
9588 {
9589 do
9590 {
9591 rValCount++;
9592 values.push_back(aValue.mfValue);
9593 fSum += aValue.mfValue;
9594 }
9595 while ((aValue.mnError == FormulaError::NONE) && aValIter.GetNext(aValue));
9596 }
9597 SetError(aValue.mnError);
9598 }
9599 else
9600 SetError( FormulaError::IllegalParameter);
9601
9602 double vMean = fSum.get() / values.size();
9603
9604 for (double v : values)
9605 vSum += (v - vMean) * (v - vMean);
9606
9607 rVal = vSum.get();
9608 }
9609
9610 void ScInterpreter::ScDBStdDev()
9611 {
9612 double fVal, fCount;
9613 GetDBStVarParams( fVal, fCount );
9614 PushDouble( sqrt(fVal/(fCount-1)));
9615 }
9616
9617 void ScInterpreter::ScDBStdDevP()
9618 {
9619 double fVal, fCount;
9620 GetDBStVarParams( fVal, fCount );
9621 PushDouble( sqrt(fVal/fCount));
9622 }
9623
9624 void ScInterpreter::ScDBVar()
9625 {
9626 double fVal, fCount;
9627 GetDBStVarParams( fVal, fCount );
9628 PushDouble(fVal/(fCount-1));
9629 }
9630
9631 void ScInterpreter::ScDBVarP()
9632 {
9633 double fVal, fCount;
9634 GetDBStVarParams( fVal, fCount );
9635 PushDouble(fVal/fCount);
9636 }
9637
9638 static bool lcl_IsTableStructuredRef(const OUString& sRefStr, sal_Int32& nIndex)
9639 {
9640 nIndex = ScGlobal::FindUnquoted(sRefStr, '[');
9641 return (nIndex > 0 && ScGlobal::FindUnquoted(sRefStr, ']', nIndex + 1) > nIndex);
9642 }
9643
9644 void ScInterpreter::ScIndirect()
9645 {
9646 sal_uInt8 nParamCount = GetByte();
9647 if ( !MustHaveParamCount( nParamCount, 1, 2 ) )
9648 return;
9649
9650 // Reference address syntax for INDIRECT is configurable.
9651 FormulaGrammar::AddressConvention eConv = maCalcConfig.meStringRefAddressSyntax;
9652 if (eConv == FormulaGrammar::CONV_UNSPECIFIED)
9653 // Use the current address syntax if unspecified.
9654 eConv = mrDoc.GetAddressConvention();
9655
9656 // either CONV_A1_XL_A1 was explicitly configured, or it wasn't possible
9657 // to determine which syntax to use during doc import
9658 bool bTryXlA1 = (eConv == FormulaGrammar::CONV_A1_XL_A1);
9659
9660 if (nParamCount == 2 && 0.0 == GetDouble() )
9661 {
9662 // Overwrite the config and try Excel R1C1.
9663 eConv = FormulaGrammar::CONV_XL_R1C1;
9664 bTryXlA1 = false;
9665 }
9666
9667 svl::SharedString sSharedRefStr = GetString();
9668 const OUString & sRefStr = sSharedRefStr.getString();
9669 if (sRefStr.isEmpty())
9670 {
9671 // Bail out early for empty cells, rely on "we do have a string" below.
9672 PushError( FormulaError::NoRef);
9673 return;
9674 }
9675
9676 const ScAddress::Details aDetails( bTryXlA1 ? FormulaGrammar::CONV_OOO : eConv, aPos );
9677 const ScAddress::Details aDetailsXlA1( FormulaGrammar::CONV_XL_A1, aPos );
9678 SCTAB nTab = aPos.Tab();
9679
9680 bool bTableRefNamed = false;
9681 sal_Int32 nTableRefNamedIndex = -1;
9682 OUString sTabRefStr;
9683
9684 // Named expressions and DB range names need to be tried first, as older 1K
9685 // columns allowed names that would now match a 16k columns cell address.
9686 do
9687 {
9688 ScRangeData* pData = ScRangeStringConverter::GetRangeDataFromString( sRefStr, nTab, mrDoc, eConv);
9689 if (!pData)
9690 break;
9691
9692 // We need this in order to obtain a good range.
9693 pData->ValidateTabRefs();
9694
9695 ScRange aRange;
9696
9697 // This is the usual way to treat named ranges containing
9698 // relative references.
9699 if (!pData->IsReference(aRange, aPos))
9700 {
9701 sTabRefStr = pData->GetSymbol();
9702 bTableRefNamed = lcl_IsTableStructuredRef(sTabRefStr, nTableRefNamedIndex);
9703 // if bTableRefNamed is true, we have a name that maps to a table structured reference.
9704 // Such a case is handled below.
9705 break;
9706 }
9707
9708 if (aRange.aStart == aRange.aEnd)
9709 PushSingleRef( aRange.aStart.Col(), aRange.aStart.Row(),
9710 aRange.aStart.Tab());
9711 else
9712 PushDoubleRef( aRange.aStart.Col(), aRange.aStart.Row(),
9713 aRange.aStart.Tab(), aRange.aEnd.Col(),
9714 aRange.aEnd.Row(), aRange.aEnd.Tab());
9715
9716 // success!
9717 return;
9718 }
9719 while (false);
9720
9721 do
9722 {
9723 if (bTableRefNamed)
9724 break;
9725
9726 const OUString & aName( sSharedRefStr.getIgnoreCaseString() );
9727 ScDBCollection::NamedDBs& rDBs = mrDoc.GetDBCollection()->getNamedDBs();
9728 const ScDBData* pData = rDBs.findByUpperName( aName);
9729 if (!pData)
9730 break;
9731
9732 ScRange aRange;
9733 pData->GetArea( aRange);
9734
9735 // In Excel, specifying a table name without [] resolves to the
9736 // same as with [], a range that excludes header and totals
9737 // rows and contains only data rows. Do the same.
9738 if (pData->HasHeader())
9739 aRange.aStart.IncRow();
9740 if (pData->HasTotals())
9741 aRange.aEnd.IncRow(-1);
9742
9743 if (aRange.aStart.Row() > aRange.aEnd.Row())
9744 break;
9745
9746 if (aRange.aStart == aRange.aEnd)
9747 PushSingleRef( aRange.aStart.Col(), aRange.aStart.Row(),
9748 aRange.aStart.Tab());
9749 else
9750 PushDoubleRef( aRange.aStart.Col(), aRange.aStart.Row(),
9751 aRange.aStart.Tab(), aRange.aEnd.Col(),
9752 aRange.aEnd.Row(), aRange.aEnd.Tab());
9753
9754 // success!
9755 return;
9756 }
9757 while (false);
9758
9759 ScRefAddress aRefAd, aRefAd2;
9760 ScAddress::ExternalInfo aExtInfo;
9761 if ( !bTableRefNamed &&
9762 (ConvertDoubleRef(mrDoc, sRefStr, nTab, aRefAd, aRefAd2, aDetails, &aExtInfo) ||
9763 ( bTryXlA1 && ConvertDoubleRef(mrDoc, sRefStr, nTab, aRefAd,
9764 aRefAd2, aDetailsXlA1, &aExtInfo) ) ) )
9765 {
9766 if (aExtInfo.mbExternal)
9767 {
9768 PushExternalDoubleRef(
9769 aExtInfo.mnFileId, aExtInfo.maTabName,
9770 aRefAd.Col(), aRefAd.Row(), aRefAd.Tab(),
9771 aRefAd2.Col(), aRefAd2.Row(), aRefAd2.Tab());
9772 }
9773 else
9774 PushDoubleRef( aRefAd, aRefAd2);
9775 }
9776 else if ( !bTableRefNamed &&
9777 (ConvertSingleRef(mrDoc, sRefStr, nTab, aRefAd, aDetails, &aExtInfo) ||
9778 ( bTryXlA1 && ConvertSingleRef (mrDoc, sRefStr, nTab, aRefAd,
9779 aDetailsXlA1, &aExtInfo) ) ) )
9780 {
9781 if (aExtInfo.mbExternal)
9782 {
9783 PushExternalSingleRef(
9784 aExtInfo.mnFileId, aExtInfo.maTabName, aRefAd.Col(), aRefAd.Row(), aRefAd.Tab());
9785 }
9786 else
9787 PushSingleRef( aRefAd);
9788 }
9789 else
9790 {
9791 // It may be even a TableRef or an external name.
9792 // Anything else that resolves to one reference could be added
9793 // here, but we don't want to compile every arbitrary string. This
9794 // is already nasty enough...
9795 sal_Int32 nIndex = bTableRefNamed ? nTableRefNamedIndex : -1;
9796 bool bTableRef = bTableRefNamed;
9797 if (!bTableRefNamed)
9798 bTableRef = lcl_IsTableStructuredRef(sRefStr, nIndex);
9799 bool bExternalName = false; // External references would had been consumed above already.
9800 if (!bTableRef)
9801 {
9802 // This is our own file name reference representation centric.. but
9803 // would work also for XL '[doc]'!name and also for
9804 // '[doc]Sheet1'!name ... sickos.
9805 if (sRefStr[0] == '\'')
9806 {
9807 // Minimum 'a'#name or 'a'!name
9808 // bTryXlA1 means try both, first our own.
9809 if (bTryXlA1 || eConv == FormulaGrammar::CONV_OOO)
9810 {
9811 nIndex = ScGlobal::FindUnquoted( sRefStr, '#');
9812 if (nIndex >= 3 && sRefStr[nIndex-1] == '\'')
9813 {
9814 bExternalName = true;
9815 eConv = FormulaGrammar::CONV_OOO;
9816 }
9817 }
9818 if (!bExternalName && (bTryXlA1 || eConv != FormulaGrammar::CONV_OOO))
9819 {
9820 nIndex = ScGlobal::FindUnquoted( sRefStr, '!');
9821 if (nIndex >= 3 && sRefStr[nIndex-1] == '\'')
9822 {
9823 bExternalName = true;
9824 }
9825 }
9826 }
9827
9828 }
9829 if (bExternalName || bTableRef)
9830 {
9831 do
9832 {
9833 ScCompiler aComp( mrDoc, aPos, mrDoc.GetGrammar());
9834 aComp.SetRefConvention( eConv); // must be after grammar
9835 std::unique_ptr<ScTokenArray> pTokArr( aComp.CompileString(bTableRefNamed ? sTabRefStr : sRefStr));
9836
9837 if (pTokArr->GetCodeError() != FormulaError::NONE || !pTokArr->GetLen())
9838 break;
9839
9840 // Whatever... use only the specific case.
9841 if (bExternalName)
9842 {
9843 const formula::FormulaToken* pTok = pTokArr->FirstToken();
9844 if (!pTok || pTok->GetType() != svExternalName)
9845 break;
9846 }
9847 else if (!pTokArr->HasOpCode( ocTableRef))
9848 break;
9849
9850 aComp.CompileTokenArray();
9851
9852 // A syntactically valid reference will generate exactly
9853 // one RPN token, a reference or error. Discard everything
9854 // else as error.
9855 if (pTokArr->GetCodeLen() != 1)
9856 break;
9857
9858 ScTokenRef xTok( pTokArr->FirstRPNToken());
9859 if (!xTok)
9860 break;
9861
9862 switch (xTok->GetType())
9863 {
9864 case svSingleRef:
9865 case svDoubleRef:
9866 case svExternalSingleRef:
9867 case svExternalDoubleRef:
9868 case svError:
9869 PushTokenRef( xTok);
9870 // success!
9871 return;
9872 default:
9873 ; // nothing
9874 }
9875 }
9876 while (false);
9877 }
9878
9879 PushError( FormulaError::NoRef);
9880 }
9881 }
9882
9883 void ScInterpreter::ScAddressFunc()
9884 {
9885 OUString sTabStr;
9886
9887 sal_uInt8 nParamCount = GetByte();
9888 if( !MustHaveParamCount( nParamCount, 2, 5 ) )
9889 return;
9890
9891 if( nParamCount >= 5 )
9892 sTabStr = GetString().getString();
9893
9894 FormulaGrammar::AddressConvention eConv = FormulaGrammar::CONV_OOO; // default
9895 if (nParamCount >= 4 && 0.0 == GetDoubleWithDefault( 1.0))
9896 eConv = FormulaGrammar::CONV_XL_R1C1;
9897 else
9898 {
9899 // If A1 syntax is requested then the actual sheet separator and format
9900 // convention depends on the syntax configured for INDIRECT to match
9901 // that, and if it is unspecified then the document's address syntax.
9902 FormulaGrammar::AddressConvention eForceConv = maCalcConfig.meStringRefAddressSyntax;
9903 if (eForceConv == FormulaGrammar::CONV_UNSPECIFIED)
9904 eForceConv = mrDoc.GetAddressConvention();
9905 if (eForceConv == FormulaGrammar::CONV_XL_A1 || eForceConv == FormulaGrammar::CONV_XL_R1C1)
9906 eConv = FormulaGrammar::CONV_XL_A1; // for anything Excel use Excel A1
9907 }
9908
9909 ScRefFlags nFlags = ScRefFlags::COL_ABS | ScRefFlags::ROW_ABS; // default
9910 if( nParamCount >= 3 )
9911 {
9912 sal_Int32 n = GetInt32WithDefault(1);
9913 switch ( n )
9914 {
9915 default :
9916 PushNoValue();
9917 return;
9918
9919 case 5:
9920 case 1 : break; // default
9921 case 6:
9922 case 2 : nFlags = ScRefFlags::ROW_ABS; break;
9923 case 7:
9924 case 3 : nFlags = ScRefFlags::COL_ABS; break;
9925 case 8:
9926 case 4 : nFlags = ScRefFlags::ZERO; break; // both relative
9927 }
9928 }
9929 nFlags |= ScRefFlags::VALID | ScRefFlags::ROW_VALID | ScRefFlags::COL_VALID;
9930
9931 SCCOL nCol = static_cast<SCCOL>(GetInt16());
9932 SCROW nRow = static_cast<SCROW>(GetInt32());
9933 if( eConv == FormulaGrammar::CONV_XL_R1C1 )
9934 {
9935 // YUCK! The XL interface actually treats rel R1C1 refs differently
9936 // than A1
9937 if( !(nFlags & ScRefFlags::COL_ABS) )
9938 nCol += aPos.Col() + 1;
9939 if( !(nFlags & ScRefFlags::ROW_ABS) )
9940 nRow += aPos.Row() + 1;
9941 }
9942
9943 --nCol;
9944 --nRow;
9945 if (nGlobalError != FormulaError::NONE || !mrDoc.ValidCol( nCol) || !mrDoc.ValidRow( nRow))
9946 {
9947 PushIllegalArgument();
9948 return;
9949 }
9950
9951 const ScAddress::Details aDetails( eConv, aPos );
9952 const ScAddress aAdr( nCol, nRow, 0);
9953 OUString aRefStr(aAdr.Format(nFlags, &mrDoc, aDetails));
9954
9955 if( nParamCount >= 5 && !sTabStr.isEmpty() )
9956 {
9957 OUString aDoc;
9958 if (eConv == FormulaGrammar::CONV_OOO)
9959 {
9960 // Isolate Tab from 'Doc'#Tab
9961 sal_Int32 nPos = ScCompiler::GetDocTabPos( sTabStr);
9962 if (nPos != -1)
9963 {
9964 if (sTabStr[nPos+1] == '$')
9965 ++nPos; // also split 'Doc'#$Tab
9966 aDoc = sTabStr.copy( 0, nPos+1);
9967 sTabStr = sTabStr.copy( nPos+1);
9968 }
9969 }
9970 /* TODO: yet unsupported external reference in CONV_XL_R1C1 syntax may
9971 * need some extra handling to isolate Tab from Doc. */
9972 if (sTabStr[0] != '\'' || !sTabStr.endsWith("'"))
9973 ScCompiler::CheckTabQuotes( sTabStr, eConv);
9974 if (!aDoc.isEmpty())
9975 sTabStr = aDoc + sTabStr;
9976 sTabStr += (eConv == FormulaGrammar::CONV_XL_R1C1 || eConv == FormulaGrammar::CONV_XL_A1) ?
9977 std::u16string_view(u"!") : std::u16string_view(u".");
9978 sTabStr += aRefStr;
9979 PushString( sTabStr );
9980 }
9981 else
9982 PushString( aRefStr );
9983 }
9984
9985 void ScInterpreter::ScOffset()
9986 {
9987 sal_uInt8 nParamCount = GetByte();
9988 if ( !MustHaveParamCount( nParamCount, 3, 5 ) )
9989 return;
9990
9991 bool bNewWidth = false;
9992 bool bNewHeight = false;
9993 sal_Int32 nColNew = 1, nRowNew = 1;
9994 if (nParamCount == 5)
9995 {
9996 if (IsMissing())
9997 PopError();
9998 else
9999 {
10000 nColNew = GetInt32();
10001 bNewWidth = true;
10002 }
10003 }
10004 if (nParamCount >= 4)
10005 {
10006 if (IsMissing())
10007 PopError();
10008 else
10009 {
10010 nRowNew = GetInt32();
10011 bNewHeight = true;
10012 }
10013 }
10014 sal_Int32 nColPlus = GetInt32();
10015 sal_Int32 nRowPlus = GetInt32();
10016 if (nGlobalError != FormulaError::NONE)
10017 {
10018 PushError( nGlobalError);
10019 return;
10020 }
10021 if (nColNew <= 0 || nRowNew <= 0)
10022 {
10023 PushIllegalArgument();
10024 return;
10025 }
10026 SCCOL nCol1(0);
10027 SCROW nRow1(0);
10028 SCTAB nTab1(0);
10029 SCCOL nCol2(0);
10030 SCROW nRow2(0);
10031 SCTAB nTab2(0);
10032 switch (GetStackType())
10033 {
10034 case svSingleRef:
10035 {
10036 PopSingleRef(nCol1, nRow1, nTab1);
10037 if (!bNewWidth && !bNewHeight)
10038 {
10039 nCol1 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1) + nColPlus);
10040 nRow1 = static_cast<SCROW>(static_cast<tools::Long>(nRow1) + nRowPlus);
10041 if (!mrDoc.ValidCol(nCol1) || !mrDoc.ValidRow(nRow1))
10042 PushIllegalArgument();
10043 else
10044 PushSingleRef(nCol1, nRow1, nTab1);
10045 }
10046 else
10047 {
10048 nCol1 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColPlus);
10049 nRow1 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowPlus);
10050 nCol2 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColNew-1);
10051 nRow2 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowNew-1);
10052 if (!mrDoc.ValidCol(nCol1) || !mrDoc.ValidRow(nRow1) ||
10053 !mrDoc.ValidCol(nCol2) || !mrDoc.ValidRow(nRow2))
10054 PushIllegalArgument();
10055 else
10056 PushDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab1);
10057 }
10058 break;
10059 }
10060 case svExternalSingleRef:
10061 {
10062 sal_uInt16 nFileId;
10063 OUString aTabName;
10064 ScSingleRefData aRef;
10065 PopExternalSingleRef(nFileId, aTabName, aRef);
10066 ScAddress aAbsRef = aRef.toAbs(mrDoc, aPos);
10067 nCol1 = aAbsRef.Col();
10068 nRow1 = aAbsRef.Row();
10069 nTab1 = aAbsRef.Tab();
10070
10071 if (!bNewWidth && !bNewHeight)
10072 {
10073 nCol1 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1) + nColPlus);
10074 nRow1 = static_cast<SCROW>(static_cast<tools::Long>(nRow1) + nRowPlus);
10075 if (!mrDoc.ValidCol(nCol1) || !mrDoc.ValidRow(nRow1))
10076 PushIllegalArgument();
10077 else
10078 PushExternalSingleRef(nFileId, aTabName, nCol1, nRow1, nTab1);
10079 }
10080 else
10081 {
10082 nCol1 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColPlus);
10083 nRow1 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowPlus);
10084 nCol2 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColNew-1);
10085 nRow2 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowNew-1);
10086 nTab2 = nTab1;
10087 if (!mrDoc.ValidCol(nCol1) || !mrDoc.ValidRow(nRow1) ||
10088 !mrDoc.ValidCol(nCol2) || !mrDoc.ValidRow(nRow2))
10089 PushIllegalArgument();
10090 else
10091 PushExternalDoubleRef(nFileId, aTabName, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
10092 }
10093 break;
10094 }
10095 case svDoubleRef:
10096 {
10097 PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
10098 if (!bNewWidth)
10099 nColNew = nCol2 - nCol1 + 1;
10100 if (!bNewHeight)
10101 nRowNew = nRow2 - nRow1 + 1;
10102 nCol1 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColPlus);
10103 nRow1 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowPlus);
10104 nCol2 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColNew-1);
10105 nRow2 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowNew-1);
10106 if (!mrDoc.ValidCol(nCol1) || !mrDoc.ValidRow(nRow1) ||
10107 !mrDoc.ValidCol(nCol2) || !mrDoc.ValidRow(nRow2) || nTab1 != nTab2)
10108 PushIllegalArgument();
10109 else
10110 PushDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab1);
10111 break;
10112 }
10113 case svExternalDoubleRef:
10114 {
10115 sal_uInt16 nFileId;
10116 OUString aTabName;
10117 ScComplexRefData aRef;
10118 PopExternalDoubleRef(nFileId, aTabName, aRef);
10119 ScRange aAbs = aRef.toAbs(mrDoc, aPos);
10120 nCol1 = aAbs.aStart.Col();
10121 nRow1 = aAbs.aStart.Row();
10122 nTab1 = aAbs.aStart.Tab();
10123 nCol2 = aAbs.aEnd.Col();
10124 nRow2 = aAbs.aEnd.Row();
10125 nTab2 = aAbs.aEnd.Tab();
10126 if (!bNewWidth)
10127 nColNew = nCol2 - nCol1 + 1;
10128 if (!bNewHeight)
10129 nRowNew = nRow2 - nRow1 + 1;
10130 nCol1 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColPlus);
10131 nRow1 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowPlus);
10132 nCol2 = static_cast<SCCOL>(static_cast<tools::Long>(nCol1)+nColNew-1);
10133 nRow2 = static_cast<SCROW>(static_cast<tools::Long>(nRow1)+nRowNew-1);
10134 if (!mrDoc.ValidCol(nCol1) || !mrDoc.ValidRow(nRow1) ||
10135 !mrDoc.ValidCol(nCol2) || !mrDoc.ValidRow(nRow2) || nTab1 != nTab2)
10136 PushIllegalArgument();
10137 else
10138 PushExternalDoubleRef(nFileId, aTabName, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
10139 break;
10140 }
10141 default:
10142 PushIllegalParameter();
10143 break;
10144 } // end switch
10145 }
10146
10147 void ScInterpreter::ScIndex()
10148 {
10149 sal_uInt8 nParamCount = GetByte();
10150 if ( !MustHaveParamCount( nParamCount, 1, 4 ) )
10151 return;
10152
10153 sal_uInt32 nArea;
10154 size_t nAreaCount;
10155 SCCOL nCol;
10156 SCROW nRow;
10157 if (nParamCount == 4)
10158 nArea = GetUInt32();
10159 else
10160 nArea = 1;
10161 bool bColMissing;
10162 if (nParamCount >= 3)
10163 {
10164 bColMissing = IsMissing();
10165 nCol = static_cast<SCCOL>(GetInt16());
10166 }
10167 else
10168 {
10169 bColMissing = false;
10170 nCol = 0;
10171 }
10172 if (nParamCount >= 2)
10173 nRow = static_cast<SCROW>(GetInt32());
10174 else
10175 nRow = 0;
10176 if (GetStackType() == svRefList)
10177 nAreaCount = (sp ? pStack[sp-1]->GetRefList()->size() : 0);
10178 else
10179 nAreaCount = 1; // one reference or array or whatever
10180 if (nGlobalError != FormulaError::NONE || nAreaCount == 0 || static_cast<size_t>(nArea) > nAreaCount)
10181 {
10182 PushError( FormulaError::NoRef);
10183 return;
10184 }
10185 else if (nArea < 1 || nCol < 0 || nRow < 0)
10186 {
10187 PushIllegalArgument();
10188 return;
10189 }
10190 switch (GetStackType())
10191 {
10192 case svMatrix:
10193 case svExternalSingleRef:
10194 case svExternalDoubleRef:
10195 {
10196 if (nArea != 1)
10197 SetError(FormulaError::IllegalArgument);
10198 sal_uInt16 nOldSp = sp;
10199 ScMatrixRef pMat = GetMatrix();
10200 if (pMat)
10201 {
10202 SCSIZE nC, nR;
10203 pMat->GetDimensions(nC, nR);
10204
10205 // Access one element of a vector independent of col/row
10206 // orientation. Excel documentation does not mention, but
10207 // i62850 had a .xls example of a row vector accessed by
10208 // row number returning one element. This
10209 // INDEX(row_vector;element) behaves the same as
10210 // INDEX(row_vector;0;element) and thus contradicts Excel
10211 // documentation where the second parameter is always
10212 // row_num.
10213 //
10214 // ODFF v1.3 in 6.14.6 INDEX states "If DataSource is a
10215 // one-dimensional row vector, Row is optional, which
10216 // effectively makes Row act as the column offset into the
10217 // vector". Guess the first Row is a typo and should read
10218 // Column instead.
10219
10220 const bool bRowVectorSpecial = (nParamCount == 2 || bColMissing);
10221 const bool bRowVectorElement = (nR == 1 && (nCol != 0 || (bRowVectorSpecial && nRow != 0)));
10222 const bool bVectorElement = (bRowVectorElement || (nC == 1 && nRow != 0));
10223
10224 if (nC == 0 || nR == 0 ||
10225 (!bVectorElement && (o3tl::make_unsigned(nCol) > nC ||
10226 o3tl::make_unsigned(nRow) > nR)))
10227 PushError( FormulaError::NoRef);
10228 else if (nCol == 0 && nRow == 0)
10229 sp = nOldSp;
10230 else if (bVectorElement)
10231 {
10232 // Vectors here don't replicate to the other dimension.
10233 SCSIZE nElement, nOtherDimension;
10234 if (bRowVectorElement && !bRowVectorSpecial)
10235 {
10236 nElement = o3tl::make_unsigned(nCol);
10237 nOtherDimension = o3tl::make_unsigned(nRow);
10238 }
10239 else
10240 {
10241 nElement = o3tl::make_unsigned(nRow);
10242 nOtherDimension = o3tl::make_unsigned(nCol);
10243 }
10244
10245 if (nElement == 0 || nElement > nC * nR || nOtherDimension > 1)
10246 PushError( FormulaError::NoRef);
10247 else
10248 {
10249 --nElement;
10250 if (pMat->IsStringOrEmpty( nElement))
10251 PushString( pMat->GetString(nElement).getString());
10252 else
10253 PushDouble( pMat->GetDouble( nElement));
10254 }
10255 }
10256 else if (nCol == 0)
10257 {
10258 ScMatrixRef pResMat = GetNewMat(nC, 1, /*bEmpty*/true);
10259 if (pResMat)
10260 {
10261 SCSIZE nRowMinus1 = static_cast<SCSIZE>(nRow - 1);
10262 for (SCSIZE i = 0; i < nC; i++)
10263 if (!pMat->IsStringOrEmpty(i, nRowMinus1))
10264 pResMat->PutDouble(pMat->GetDouble(i,
10265 nRowMinus1), i, 0);
10266 else
10267 pResMat->PutString(pMat->GetString(i, nRowMinus1), i, 0);
10268
10269 PushMatrix(pResMat);
10270 }
10271 else
10272 PushError( FormulaError::NoRef);
10273 }
10274 else if (nRow == 0)
10275 {
10276 ScMatrixRef pResMat = GetNewMat(1, nR, /*bEmpty*/true);
10277 if (pResMat)
10278 {
10279 SCSIZE nColMinus1 = static_cast<SCSIZE>(nCol - 1);
10280 for (SCSIZE i = 0; i < nR; i++)
10281 if (!pMat->IsStringOrEmpty(nColMinus1, i))
10282 pResMat->PutDouble(pMat->GetDouble(nColMinus1,
10283 i), i);
10284 else
10285 pResMat->PutString(pMat->GetString(nColMinus1, i), i);
10286 PushMatrix(pResMat);
10287 }
10288 else
10289 PushError( FormulaError::NoRef);
10290 }
10291 else
10292 {
10293 if (!pMat->IsStringOrEmpty( static_cast<SCSIZE>(nCol-1),
10294 static_cast<SCSIZE>(nRow-1)))
10295 PushDouble( pMat->GetDouble(
10296 static_cast<SCSIZE>(nCol-1),
10297 static_cast<SCSIZE>(nRow-1)));
10298 else
10299 PushString( pMat->GetString(
10300 static_cast<SCSIZE>(nCol-1),
10301 static_cast<SCSIZE>(nRow-1)).getString());
10302 }
10303 }
10304 }
10305 break;
10306 case svSingleRef:
10307 {
10308 SCCOL nCol1 = 0;
10309 SCROW nRow1 = 0;
10310 SCTAB nTab1 = 0;
10311 PopSingleRef( nCol1, nRow1, nTab1);
10312 if (nCol > 1 || nRow > 1)
10313 PushError( FormulaError::NoRef);
10314 else
10315 PushSingleRef( nCol1, nRow1, nTab1);
10316 }
10317 break;
10318 case svDoubleRef:
10319 case svRefList:
10320 {
10321 SCCOL nCol1 = 0;
10322 SCROW nRow1 = 0;
10323 SCTAB nTab1 = 0;
10324 SCCOL nCol2 = 0;
10325 SCROW nRow2 = 0;
10326 SCTAB nTab2 = 0;
10327 bool bRowArray = false;
10328 if (GetStackType() == svRefList)
10329 {
10330 FormulaConstTokenRef xRef = PopToken();
10331 if (nGlobalError != FormulaError::NONE || !xRef)
10332 {
10333 PushError( FormulaError::NoRef);
10334 return;
10335 }
10336 ScRange aRange( ScAddress::UNINITIALIZED);
10337 DoubleRefToRange( (*(xRef->GetRefList()))[nArea-1], aRange);
10338 aRange.GetVars( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
10339 if ( nParamCount == 2 && nRow1 == nRow2 )
10340 bRowArray = true;
10341 }
10342 else
10343 {
10344 PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
10345 if ( nParamCount == 2 && nRow1 == nRow2 )
10346 bRowArray = true;
10347 }
10348 if ( nTab1 != nTab2 ||
10349 (nCol > 0 && nCol1+nCol-1 > nCol2) ||
10350 (nRow > 0 && nRow1+nRow-1 > nRow2 && !bRowArray ) ||
10351 ( nRow > nCol2 - nCol1 + 1 && bRowArray ))
10352 PushError( FormulaError::NoRef);
10353 else if (nCol == 0 && nRow == 0)
10354 {
10355 if ( nCol1 == nCol2 && nRow1 == nRow2 )
10356 PushSingleRef( nCol1, nRow1, nTab1 );
10357 else
10358 PushDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab1 );
10359 }
10360 else if (nRow == 0)
10361 {
10362 if ( nRow1 == nRow2 )
10363 PushSingleRef( nCol1+nCol-1, nRow1, nTab1 );
10364 else
10365 PushDoubleRef( nCol1+nCol-1, nRow1, nTab1,
10366 nCol1+nCol-1, nRow2, nTab1 );
10367 }
10368 else if (nCol == 0)
10369 {
10370 if ( nCol1 == nCol2 )
10371 PushSingleRef( nCol1, nRow1+nRow-1, nTab1 );
10372 else if ( bRowArray )
10373 {
10374 nCol =static_cast<SCCOL>(nRow);
10375 nRow = 1;
10376 PushSingleRef( nCol1+nCol-1, nRow1+nRow-1, nTab1);
10377 }
10378 else
10379 PushDoubleRef( nCol1, nRow1+nRow-1, nTab1,
10380 nCol2, nRow1+nRow-1, nTab1);
10381 }
10382 else
10383 PushSingleRef( nCol1+nCol-1, nRow1+nRow-1, nTab1);
10384 }
10385 break;
10386 default:
10387 PopError();
10388 PushError( FormulaError::NoRef);
10389 }
10390 }
10391
10392 void ScInterpreter::ScMultiArea()
10393 {
10394 // Legacy support, convert to RefList
10395 sal_uInt8 nParamCount = GetByte();
10396 if (MustHaveParamCountMin( nParamCount, 1))
10397 {
10398 while (nGlobalError == FormulaError::NONE && nParamCount-- > 1)
10399 {
10400 ScUnionFunc();
10401 }
10402 }
10403 }
10404
10405 void ScInterpreter::ScAreas()
10406 {
10407 sal_uInt8 nParamCount = GetByte();
10408 if (!MustHaveParamCount( nParamCount, 1))
10409 return;
10410
10411 size_t nCount = 0;
10412 switch (GetStackType())
10413 {
10414 case svSingleRef:
10415 {
10416 FormulaConstTokenRef xT = PopToken();
10417 ValidateRef( *xT->GetSingleRef());
10418 ++nCount;
10419 }
10420 break;
10421 case svDoubleRef:
10422 {
10423 FormulaConstTokenRef xT = PopToken();
10424 ValidateRef( *xT->GetDoubleRef());
10425 ++nCount;
10426 }
10427 break;
10428 case svRefList:
10429 {
10430 FormulaConstTokenRef xT = PopToken();
10431 ValidateRef( *(xT->GetRefList()));
10432 nCount += xT->GetRefList()->size();
10433 }
10434 break;
10435 default:
10436 SetError( FormulaError::IllegalParameter);
10437 }
10438 PushDouble( double(nCount));
10439 }
10440
10441 void ScInterpreter::ScCurrency()
10442 {
10443 sal_uInt8 nParamCount = GetByte();
10444 if ( !MustHaveParamCount( nParamCount, 1, 2 ) )
10445 return;
10446
10447 OUString aStr;
10448 double fDec;
10449 if (nParamCount == 2)
10450 {
10451 fDec = ::rtl::math::approxFloor(GetDouble());
10452 if (fDec < -15.0 || fDec > 15.0)
10453 {
10454 PushIllegalArgument();
10455 return;
10456 }
10457 }
10458 else
10459 fDec = 2.0;
10460 double fVal = GetDouble();
10461 double fFac;
10462 if ( fDec != 0.0 )
10463 fFac = pow( double(10), fDec );
10464 else
10465 fFac = 1.0;
10466 if (fVal < 0.0)
10467 fVal = ceil(fVal*fFac-0.5)/fFac;
10468 else
10469 fVal = floor(fVal*fFac+0.5)/fFac;
10470 const Color* pColor = nullptr;
10471 if ( fDec < 0.0 )
10472 fDec = 0.0;
10473 sal_uLong nIndex = mrContext.NFGetStandardFormat(
10474 SvNumFormatType::CURRENCY,
10475 ScGlobal::eLnge);
10476 if ( static_cast<sal_uInt16>(fDec) != mrContext.NFGetFormatPrecision( nIndex ) )
10477 {
10478 OUString sFormatString = mrContext.NFGenerateFormat(
10479 nIndex,
10480 ScGlobal::eLnge,
10481 true, // with thousands separator
10482 false, // not red
10483 static_cast<sal_uInt16>(fDec));// decimal places
10484 if (!mrContext.NFGetPreviewString(sFormatString,
10485 fVal,
10486 aStr,
10487 &pColor,
10488 ScGlobal::eLnge))
10489 SetError(FormulaError::IllegalArgument);
10490 }
10491 else
10492 {
10493 mrContext.NFGetOutputString(fVal, nIndex, aStr, &pColor);
10494 }
10495 PushString(aStr);
10496 }
10497
10498 void ScInterpreter::ScReplace()
10499 {
10500 if ( !MustHaveParamCount( GetByte(), 4 ) )
10501 return;
10502
10503 OUString aNewStr = GetString().getString();
10504 sal_Int32 nCount = GetStringPositionArgument();
10505 sal_Int32 nPos = GetStringPositionArgument();
10506 OUString aOldStr = GetString().getString();
10507 if (nPos < 1 || nCount < 0)
10508 PushIllegalArgument();
10509 else
10510 {
10511 sal_Int32 nLen = aOldStr.getLength();
10512 if (nPos > nLen + 1)
10513 nPos = nLen + 1;
10514 if (nCount > nLen - nPos + 1)
10515 nCount = nLen - nPos + 1;
10516 sal_Int32 nIdx = 0;
10517 sal_Int32 nCnt = 0;
10518 while ( nIdx < nLen && nPos > nCnt + 1 )
10519 {
10520 aOldStr.iterateCodePoints( &nIdx );
10521 ++nCnt;
10522 }
10523 sal_Int32 nStart = nIdx;
10524 while ( nIdx < nLen && nPos + nCount - 1 > nCnt )
10525 {
10526 aOldStr.iterateCodePoints( &nIdx );
10527 ++nCnt;
10528 }
10529 if ( CheckStringResultLen( aOldStr, aNewStr.getLength() - (nIdx - nStart) ) )
10530 aOldStr = aOldStr.replaceAt( nStart, nIdx - nStart, aNewStr );
10531 PushString( aOldStr );
10532 }
10533 }
10534
10535 void ScInterpreter::ScFixed()
10536 {
10537 sal_uInt8 nParamCount = GetByte();
10538 if ( !MustHaveParamCount( nParamCount, 1, 3 ) )
10539 return;
10540
10541 OUString aStr;
10542 double fDec;
10543 bool bThousand;
10544 if (nParamCount == 3)
10545 bThousand = !GetBool(); // Param true: no thousands separator
10546 else
10547 bThousand = true;
10548 if (nParamCount >= 2)
10549 {
10550 fDec = ::rtl::math::approxFloor(GetDoubleWithDefault( 2.0 ));
10551 if (fDec < -15.0 || fDec > 15.0)
10552 {
10553 PushIllegalArgument();
10554 return;
10555 }
10556 }
10557 else
10558 fDec = 2.0;
10559 double fVal = GetDouble();
10560 double fFac;
10561 if ( fDec != 0.0 )
10562 fFac = pow( double(10), fDec );
10563 else
10564 fFac = 1.0;
10565 if (fVal < 0.0)
10566 fVal = ceil(fVal*fFac-0.5)/fFac;
10567 else
10568 fVal = floor(fVal*fFac+0.5)/fFac;
10569 const Color* pColor = nullptr;
10570 if (fDec < 0.0)
10571 fDec = 0.0;
10572 sal_uLong nIndex = mrContext.NFGetStandardFormat(
10573 SvNumFormatType::NUMBER,
10574 ScGlobal::eLnge);
10575 OUString sFormatString = mrContext.NFGenerateFormat(
10576 nIndex,
10577 ScGlobal::eLnge,
10578 bThousand, // with thousands separator
10579 false, // not red
10580 static_cast<sal_uInt16>(fDec));// decimal places
10581 if (!mrContext.NFGetPreviewString(sFormatString,
10582 fVal,
10583 aStr,
10584 &pColor,
10585 ScGlobal::eLnge))
10586 PushIllegalArgument();
10587 else
10588 PushString(aStr);
10589 }
10590
10591 void ScInterpreter::ScFind()
10592 {
10593 sal_uInt8 nParamCount = GetByte();
10594 if ( !MustHaveParamCount( nParamCount, 2, 3 ) )
10595 return;
10596
10597 sal_Int32 nCnt;
10598 if (nParamCount == 3)
10599 nCnt = GetDouble();
10600 else
10601 nCnt = 1;
10602 OUString sStr = GetString().getString();
10603 if (nCnt < 1 || nCnt > sStr.getLength())
10604 PushNoValue();
10605 else
10606 {
10607 sal_Int32 nPos = sStr.indexOf(GetString().getString(), nCnt - 1);
10608 if (nPos == -1)
10609 PushNoValue();
10610 else
10611 {
10612 sal_Int32 nIdx = 0;
10613 nCnt = 0;
10614 while ( nIdx < nPos )
10615 {
10616 sStr.iterateCodePoints( &nIdx );
10617 ++nCnt;
10618 }
10619 PushDouble( static_cast<double>(nCnt + 1) );
10620 }
10621 }
10622 }
10623
10624 void ScInterpreter::ScExact()
10625 {
10626 nFuncFmtType = SvNumFormatType::LOGICAL;
10627 if ( MustHaveParamCount( GetByte(), 2 ) )
10628 {
10629 svl::SharedString s1 = GetString();
10630 svl::SharedString s2 = GetString();
10631 PushInt( int(s1.getData() == s2.getData()) );
10632 }
10633 }
10634
10635 void ScInterpreter::ScLeft()
10636 {
10637 sal_uInt8 nParamCount = GetByte();
10638 if ( !MustHaveParamCount( nParamCount, 1, 2 ) )
10639 return;
10640
10641 sal_Int32 n;
10642 if (nParamCount == 2)
10643 {
10644 n = GetStringPositionArgument();
10645 if (n < 0)
10646 {
10647 PushIllegalArgument();
10648 return ;
10649 }
10650 }
10651 else
10652 n = 1;
10653 OUString aStr = GetString().getString();
10654 sal_Int32 nIdx = 0;
10655 sal_Int32 nCnt = 0;
10656 while ( nIdx < aStr.getLength() && n > nCnt++ )
10657 aStr.iterateCodePoints( &nIdx );
10658 aStr = aStr.copy( 0, nIdx );
10659 PushString( aStr );
10660 }
10661
10662 namespace {
10663
10664 struct UBlockScript {
10665 UBlockCode from;
10666 UBlockCode to;
10667 };
10668
10669 }
10670
10671 const UBlockScript scriptList[] = {
10672 {UBLOCK_HANGUL_JAMO, UBLOCK_HANGUL_JAMO},
10673 {UBLOCK_CJK_RADICALS_SUPPLEMENT, UBLOCK_HANGUL_SYLLABLES},
10674 {UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS,UBLOCK_CJK_RADICALS_SUPPLEMENT },
10675 {UBLOCK_IDEOGRAPHIC_DESCRIPTION_CHARACTERS,UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS},
10676 {UBLOCK_CJK_COMPATIBILITY_FORMS, UBLOCK_CJK_COMPATIBILITY_FORMS},
10677 {UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS, UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS},
10678 {UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT},
10679 {UBLOCK_CJK_STROKES, UBLOCK_CJK_STROKES}
10680 };
10681 static bool IsDBCS(sal_Unicode currentChar)
10682 {
10683 // for the locale of ja-JP, character U+0x005c and U+0x20ac should be ScriptType::Asian
10684 if( (currentChar == 0x005c || currentChar == 0x20ac) &&
10685 (MsLangId::getConfiguredSystemLanguage() == LANGUAGE_JAPANESE) )
10686 return true;
10687 sal_uInt16 i;
10688 bool bRet = false;
10689 UBlockCode block = ublock_getCode(currentChar);
10690 for ( i = 0; i < SAL_N_ELEMENTS(scriptList); i++) {
10691 if (block <= scriptList[i].to) break;
10692 }
10693 bRet = (i < SAL_N_ELEMENTS(scriptList) && block >= scriptList[i].from);
10694 return bRet;
10695 }
10696 static sal_Int32 lcl_getLengthB( std::u16string_view str, sal_Int32 nPos )
10697 {
10698 sal_Int32 index = 0;
10699 sal_Int32 length = 0;
10700 while ( index < nPos )
10701 {
10702 if (IsDBCS(str[index]))
10703 length += 2;
10704 else
10705 length++;
10706 index++;
10707 }
10708 return length;
10709 }
10710 static sal_Int32 getLengthB(std::u16string_view str)
10711 {
10712 if(str.empty())
10713 return 0;
10714 else
10715 return lcl_getLengthB( str, str.size() );
10716 }
10717 void ScInterpreter::ScLenB()
10718 {
10719 PushDouble( getLengthB(GetString().getString()) );
10720 }
10721 static OUString lcl_RightB(const OUString &rStr, sal_Int32 n)
10722 {
10723 if( n < getLengthB(rStr) )
10724 {
10725 OUStringBuffer aBuf(rStr);
10726 sal_Int32 index = aBuf.getLength();
10727 while(index-- >= 0)
10728 {
10729 if(0 == n)
10730 {
10731 aBuf.remove( 0, index + 1);
10732 break;
10733 }
10734 if(-1 == n)
10735 {
10736 aBuf.remove( 0, index + 2 );
10737 aBuf.insert( 0, " ");
10738 break;
10739 }
10740 if(IsDBCS(aBuf[index]))
10741 n -= 2;
10742 else
10743 n--;
10744 }
10745 return aBuf.makeStringAndClear();
10746 }
10747 return rStr;
10748 }
10749 void ScInterpreter::ScRightB()
10750 {
10751 sal_uInt8 nParamCount = GetByte();
10752 if ( !MustHaveParamCount( nParamCount, 1, 2 ) )
10753 return;
10754
10755 sal_Int32 n;
10756 if (nParamCount == 2)
10757 {
10758 n = GetStringPositionArgument();
10759 if (n < 0)
10760 {
10761 PushIllegalArgument();
10762 return ;
10763 }
10764 }
10765 else
10766 n = 1;
10767 OUString aStr(lcl_RightB(GetString().getString(), n));
10768 PushString( aStr );
10769 }
10770 static OUString lcl_LeftB(const OUString &rStr, sal_Int32 n)
10771 {
10772 if( n < getLengthB(rStr) )
10773 {
10774 OUStringBuffer aBuf(rStr);
10775 sal_Int32 index = -1;
10776 while(index++ < aBuf.getLength())
10777 {
10778 if(0 == n)
10779 {
10780 aBuf.truncate(index);
10781 break;
10782 }
10783 if(-1 == n)
10784 {
10785 aBuf.truncate( index - 1 );
10786 aBuf.append(" ");
10787 break;
10788 }
10789 if(IsDBCS(aBuf[index]))
10790 n -= 2;
10791 else
10792 n--;
10793 }
10794 return aBuf.makeStringAndClear();
10795 }
10796 return rStr;
10797 }
10798 void ScInterpreter::ScLeftB()
10799 {
10800 sal_uInt8 nParamCount = GetByte();
10801 if ( !MustHaveParamCount( nParamCount, 1, 2 ) )
10802 return;
10803
10804 sal_Int32 n;
10805 if (nParamCount == 2)
10806 {
10807 n = GetStringPositionArgument();
10808 if (n < 0)
10809 {
10810 PushIllegalArgument();
10811 return ;
10812 }
10813 }
10814 else
10815 n = 1;
10816 OUString aStr(lcl_LeftB(GetString().getString(), n));
10817 PushString( aStr );
10818 }
10819 void ScInterpreter::ScMidB()
10820 {
10821 if ( !MustHaveParamCount( GetByte(), 3 ) )
10822 return;
10823
10824 const sal_Int32 nCount = GetStringPositionArgument();
10825 const sal_Int32 nStart = GetStringPositionArgument();
10826 OUString aStr = GetString().getString();
10827 if (nStart < 1 || nCount < 0)
10828 PushIllegalArgument();
10829 else
10830 {
10831
10832 aStr = lcl_LeftB(aStr, nStart + nCount - 1);
10833 sal_Int32 nCnt = getLengthB(aStr) - nStart + 1;
10834 aStr = lcl_RightB(aStr, std::max<sal_Int32>(nCnt,0));
10835 PushString(aStr);
10836 }
10837 }
10838
10839 void ScInterpreter::ScReplaceB()
10840 {
10841 if ( !MustHaveParamCount( GetByte(), 4 ) )
10842 return;
10843
10844 OUString aNewStr = GetString().getString();
10845 const sal_Int32 nCount = GetStringPositionArgument();
10846 const sal_Int32 nPos = GetStringPositionArgument();
10847 OUString aOldStr = GetString().getString();
10848 int nLen = getLengthB( aOldStr );
10849 if (nPos < 1.0 || nPos > nLen || nCount < 0.0 || nPos + nCount -1 > nLen)
10850 PushIllegalArgument();
10851 else
10852 {
10853 // REPLACEB(aOldStr;nPos;nCount;aNewStr) is the same as
10854 // LEFTB(aOldStr;nPos-1) & aNewStr & RIGHT(aOldStr;LENB(aOldStr)-(nPos - 1)-nCount)
10855 OUString aStr1 = lcl_LeftB( aOldStr, nPos - 1 );
10856 OUString aStr3 = lcl_RightB( aOldStr, nLen - nPos - nCount + 1);
10857
10858 PushString( aStr1 + aNewStr + aStr3 );
10859 }
10860 }
10861
10862 void ScInterpreter::ScFindB()
10863 {
10864 sal_uInt8 nParamCount = GetByte();
10865 if ( !MustHaveParamCount( nParamCount, 2, 3 ) )
10866 return;
10867
10868 sal_Int32 nStart;
10869 if ( nParamCount == 3 )
10870 nStart = GetStringPositionArgument();
10871 else
10872 nStart = 1;
10873 OUString aStr = GetString().getString();
10874 int nLen = getLengthB( aStr );
10875 OUString asStr = GetString().getString();
10876 int nsLen = getLengthB( asStr );
10877 if ( nStart < 1 || nStart > nLen - nsLen + 1 )
10878 PushIllegalArgument();
10879 else
10880 {
10881 // create a string from sStr starting at nStart
10882 OUString aBuf = lcl_RightB( aStr, nLen - nStart + 1 );
10883 // search aBuf for asStr
10884 sal_Int32 nPos = aBuf.indexOf( asStr, 0 );
10885 if ( nPos == -1 )
10886 PushNoValue();
10887 else
10888 {
10889 // obtain byte value of nPos
10890 int nBytePos = lcl_getLengthB( aBuf, nPos );
10891 PushDouble( nBytePos + nStart );
10892 }
10893 }
10894 }
10895
10896 void ScInterpreter::ScSearchB()
10897 {
10898 sal_uInt8 nParamCount = GetByte();
10899 if ( !MustHaveParamCount( nParamCount, 2, 3 ) )
10900 return;
10901
10902 sal_Int32 nStart;
10903 if ( nParamCount == 3 )
10904 {
10905 nStart = GetStringPositionArgument();
10906 if( nStart < 1 )
10907 {
10908 PushIllegalArgument();
10909 return;
10910 }
10911 }
10912 else
10913 nStart = 1;
10914 OUString aStr = GetString().getString();
10915 sal_Int32 nLen = getLengthB( aStr );
10916 OUString asStr = GetString().getString();
10917 sal_Int32 nsLen = nStart - 1;
10918 if( nsLen >= nLen )
10919 PushNoValue();
10920 else
10921 {
10922 // create a string from sStr starting at nStart
10923 OUString aSubStr( lcl_RightB( aStr, nLen - nStart + 1 ) );
10924 // search aSubStr for asStr
10925 sal_Int32 nPos = 0;
10926 sal_Int32 nEndPos = aSubStr.getLength();
10927 utl::SearchParam::SearchType eSearchType = DetectSearchType( asStr, mrDoc );
10928 utl::SearchParam sPar( asStr, eSearchType, false, '~', false );
10929 utl::TextSearch sT( sPar, ScGlobal::getCharClass() );
10930 if ( !sT.SearchForward( aSubStr, &nPos, &nEndPos ) )
10931 PushNoValue();
10932 else
10933 {
10934 // obtain byte value of nPos
10935 int nBytePos = lcl_getLengthB( aSubStr, nPos );
10936 PushDouble( nBytePos + nStart );
10937 }
10938 }
10939 }
10940
10941 void ScInterpreter::ScRight()
10942 {
10943 sal_uInt8 nParamCount = GetByte();
10944 if ( !MustHaveParamCount( nParamCount, 1, 2 ) )
10945 return;
10946
10947 sal_Int32 n;
10948 if (nParamCount == 2)
10949 {
10950 n = GetStringPositionArgument();
10951 if (n < 0)
10952 {
10953 PushIllegalArgument();
10954 return ;
10955 }
10956 }
10957 else
10958 n = 1;
10959 OUString aStr = GetString().getString();
10960 sal_Int32 nLen = aStr.getLength();
10961 if ( nLen <= n )
10962 PushString( aStr );
10963 else
10964 {
10965 sal_Int32 nIdx = nLen;
10966 sal_Int32 nCnt = 0;
10967 while ( nIdx > 0 && n > nCnt )
10968 {
10969 aStr.iterateCodePoints( &nIdx, -1 );
10970 ++nCnt;
10971 }
10972 aStr = aStr.copy( nIdx, nLen - nIdx );
10973 PushString( aStr );
10974 }
10975 }
10976
10977 void ScInterpreter::ScSearch()
10978 {
10979 sal_uInt8 nParamCount = GetByte();
10980 if ( !MustHaveParamCount( nParamCount, 2, 3 ) )
10981 return;
10982
10983 sal_Int32 nStart;
10984 if (nParamCount == 3)
10985 {
10986 nStart = GetStringPositionArgument();
10987 if( nStart < 1 )
10988 {
10989 PushIllegalArgument();
10990 return;
10991 }
10992 }
10993 else
10994 nStart = 1;
10995 OUString sStr = GetString().getString();
10996 OUString SearchStr = GetString().getString();
10997 sal_Int32 nPos = nStart - 1;
10998 sal_Int32 nEndPos = sStr.getLength();
10999 if( nPos >= nEndPos )
11000 PushNoValue();
11001 else
11002 {
11003 utl::SearchParam::SearchType eSearchType = DetectSearchType( SearchStr, mrDoc );
11004 utl::SearchParam sPar(SearchStr, eSearchType, false, '~', false);
11005 utl::TextSearch sT( sPar, ScGlobal::getCharClass() );
11006 bool bBool = sT.SearchForward(sStr, &nPos, &nEndPos);
11007 if (!bBool)
11008 PushNoValue();
11009 else
11010 {
11011 sal_Int32 nIdx = 0;
11012 sal_Int32 nCnt = 0;
11013 while ( nIdx < nPos )
11014 {
11015 sStr.iterateCodePoints( &nIdx );
11016 ++nCnt;
11017 }
11018 PushDouble( static_cast<double>(nCnt + 1) );
11019 }
11020 }
11021 }
11022
11023 void ScInterpreter::ScRegex()
11024 {
11025 const sal_uInt8 nParamCount = GetByte();
11026 if (!MustHaveParamCount( nParamCount, 2, 4))
11027 return;
11028
11029 // Flags are supported only for replacement, search match flags can be
11030 // individually and much more flexible set in the regular expression
11031 // pattern using (?ismwx-ismwx)
11032 bool bGlobalReplacement = false;
11033 sal_Int32 nOccurrence = 1; // default first occurrence, if any
11034 if (nParamCount == 4)
11035 {
11036 // Argument can be either string or double.
11037 double fOccurrence;
11038 svl::SharedString aFlagsString;
11039 bool bDouble;
11040 if (!IsMissing())
11041 bDouble = GetDoubleOrString( fOccurrence, aFlagsString);
11042 else
11043 {
11044 // For an omitted argument keep the default.
11045 PopError();
11046 bDouble = true;
11047 fOccurrence = nOccurrence;
11048 }
11049 if (nGlobalError != FormulaError::NONE)
11050 {
11051 PushError( nGlobalError);
11052 return;
11053 }
11054 if (bDouble)
11055 {
11056 if (!CheckStringPositionArgument( fOccurrence))
11057 {
11058 PushError( FormulaError::IllegalArgument);
11059 return;
11060 }
11061 nOccurrence = static_cast<sal_Int32>(fOccurrence);
11062 }
11063 else
11064 {
11065 const OUString aFlags( aFlagsString.getString());
11066 // Empty flags string is valid => no flag set.
11067 if (aFlags.getLength() > 1)
11068 {
11069 // Only one flag supported.
11070 PushIllegalArgument();
11071 return;
11072 }
11073 if (aFlags.getLength() == 1)
11074 {
11075 if (aFlags.indexOf('g') >= 0)
11076 bGlobalReplacement = true;
11077 else
11078 {
11079 // Unsupported flag.
11080 PushIllegalArgument();
11081 return;
11082 }
11083 }
11084 }
11085 }
11086
11087 bool bReplacement = false;
11088 OUString aReplacement;
11089 if (nParamCount >= 3)
11090 {
11091 // A missing argument is not an empty string to replace the match.
11092 // nOccurrence==0 forces no replacement, so simply discard the
11093 // argument.
11094 if (IsMissing() || nOccurrence == 0)
11095 PopError();
11096 else
11097 {
11098 aReplacement = GetString().getString();
11099 bReplacement = true;
11100 }
11101 }
11102 // If bGlobalReplacement==true and bReplacement==false then
11103 // bGlobalReplacement is silently ignored.
11104
11105 const OUString aExpression = GetString().getString();
11106 const OUString aText = GetString().getString();
11107
11108 if (nGlobalError != FormulaError::NONE)
11109 {
11110 PushError( nGlobalError);
11111 return;
11112 }
11113
11114 // 0-th match or replacement is none, return original string early.
11115 if (nOccurrence == 0)
11116 {
11117 PushString( aText);
11118 return;
11119 }
11120
11121 const icu::UnicodeString aIcuExpression(
11122 false, reinterpret_cast<const UChar*>(aExpression.getStr()), aExpression.getLength());
11123 UErrorCode status = U_ZERO_ERROR;
11124 icu::RegexMatcher aRegexMatcher( aIcuExpression, 0, status);
11125 if (U_FAILURE(status))
11126 {
11127 // Invalid regex.
11128 PushIllegalArgument();
11129 return;
11130 }
11131 // Guard against pathological patterns, limit steps of engine, see
11132 // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1RegexMatcher.html#a6ebcfcab4fe6a38678c0291643a03a00
11133 aRegexMatcher.setTimeLimit( 23*1000, status);
11134
11135 const icu::UnicodeString aIcuText(false, reinterpret_cast<const UChar*>(aText.getStr()), aText.getLength());
11136 aRegexMatcher.reset( aIcuText);
11137
11138 if (!bReplacement)
11139 {
11140 // Find n-th occurrence.
11141 sal_Int32 nCount = 0;
11142 while (aRegexMatcher.find(status) && U_SUCCESS(status) && ++nCount < nOccurrence)
11143 ;
11144 if (U_FAILURE(status))
11145 {
11146 // Some error.
11147 PushIllegalArgument();
11148 return;
11149 }
11150 // n-th match found?
11151 if (nCount != nOccurrence)
11152 {
11153 PushError( FormulaError::NotAvailable);
11154 return;
11155 }
11156 // Extract matched text.
11157 icu::UnicodeString aMatch( aRegexMatcher.group( status));
11158 if (U_FAILURE(status))
11159 {
11160 // Some error.
11161 PushIllegalArgument();
11162 return;
11163 }
11164 OUString aResult( reinterpret_cast<const sal_Unicode*>(aMatch.getBuffer()), aMatch.length());
11165 PushString( aResult);
11166 return;
11167 }
11168
11169 const icu::UnicodeString aIcuReplacement(
11170 false, reinterpret_cast<const UChar*>(aReplacement.getStr()), aReplacement.getLength());
11171 icu::UnicodeString aReplaced;
11172 if (bGlobalReplacement)
11173 // Replace all occurrences of match with replacement.
11174 aReplaced = aRegexMatcher.replaceAll( aIcuReplacement, status);
11175 else if (nOccurrence == 1)
11176 // Replace first occurrence of match with replacement.
11177 aReplaced = aRegexMatcher.replaceFirst( aIcuReplacement, status);
11178 else
11179 {
11180 // Replace n-th occurrence of match with replacement.
11181 sal_Int32 nCount = 0;
11182 while (aRegexMatcher.find(status) && U_SUCCESS(status))
11183 {
11184 // XXX NOTE: After several RegexMatcher::find() the
11185 // RegexMatcher::appendReplacement() still starts at the
11186 // beginning (or after the last appendReplacement() position
11187 // which is none here) and copies the original text up to the
11188 // current found match and then replaces the found match.
11189 if (++nCount == nOccurrence)
11190 {
11191 aRegexMatcher.appendReplacement( aReplaced, aIcuReplacement, status);
11192 break;
11193 }
11194 }
11195 aRegexMatcher.appendTail( aReplaced);
11196 }
11197 if (U_FAILURE(status))
11198 {
11199 // Some error, e.g. extraneous $1 without group.
11200 PushIllegalArgument();
11201 return;
11202 }
11203 OUString aResult( reinterpret_cast<const sal_Unicode*>(aReplaced.getBuffer()), aReplaced.length());
11204 PushString( aResult);
11205 }
11206
11207 void ScInterpreter::ScMid()
11208 {
11209 if ( !MustHaveParamCount( GetByte(), 3 ) )
11210 return;
11211
11212 const sal_Int32 nSubLen = GetStringPositionArgument();
11213 const sal_Int32 nStart = GetStringPositionArgument();
11214 OUString aStr = GetString().getString();
11215 if ( nStart < 1 || nSubLen < 0 )
11216 PushIllegalArgument();
11217 else if (nStart > kScInterpreterMaxStrLen || nSubLen > kScInterpreterMaxStrLen)
11218 PushError(FormulaError::StringOverflow);
11219 else
11220 {
11221 sal_Int32 nLen = aStr.getLength();
11222 sal_Int32 nIdx = 0;
11223 sal_Int32 nCnt = 0;
11224 while ( nIdx < nLen && nStart - 1 > nCnt )
11225 {
11226 aStr.iterateCodePoints( &nIdx );
11227 ++nCnt;
11228 }
11229 sal_Int32 nIdx0 = nIdx; //start position
11230
11231 while ( nIdx < nLen && nStart + nSubLen - 1 > nCnt )
11232 {
11233 aStr.iterateCodePoints( &nIdx );
11234 ++nCnt;
11235 }
11236 aStr = aStr.copy( nIdx0, nIdx - nIdx0 );
11237 PushString( aStr );
11238 }
11239 }
11240
11241 void ScInterpreter::ScText()
11242 {
11243 if ( !MustHaveParamCount( GetByte(), 2 ) )
11244 return;
11245
11246 OUString sFormatString = GetString().getString();
11247 svl::SharedString aStr;
11248 bool bString = false;
11249 double fVal = 0.0;
11250 switch (GetStackType())
11251 {
11252 case svError:
11253 PopError();
11254 break;
11255 case svDouble:
11256 fVal = PopDouble();
11257 break;
11258 default:
11259 {
11260 FormulaConstTokenRef xTok( PopToken());
11261 if (nGlobalError == FormulaError::NONE)
11262 {
11263 PushTokenRef( xTok);
11264 // Temporarily override the ConvertStringToValue()
11265 // error for GetCellValue() / GetCellValueOrZero()
11266 FormulaError nSErr = mnStringNoValueError;
11267 mnStringNoValueError = FormulaError::NotNumericString;
11268 fVal = GetDouble();
11269 mnStringNoValueError = nSErr;
11270 if (nGlobalError == FormulaError::NotNumericString)
11271 {
11272 // Not numeric.
11273 nGlobalError = FormulaError::NONE;
11274 PushTokenRef( xTok);
11275 aStr = GetString();
11276 bString = true;
11277 }
11278 }
11279 }
11280 }
11281 if (nGlobalError != FormulaError::NONE)
11282 PushError( nGlobalError);
11283 else if (sFormatString.isEmpty())
11284 {
11285 // Mimic the Excel behaviour that
11286 // * anything numeric returns an empty string
11287 // * text convertible to numeric returns an empty string
11288 // * any other text returns that text
11289 // Conversion was detected above.
11290 if (bString)
11291 PushString( aStr);
11292 else
11293 PushString( OUString());
11294 }
11295 else
11296 {
11297 OUString aResult;
11298 const Color* pColor = nullptr;
11299 LanguageType eCellLang;
11300 const ScPatternAttr* pPattern = mrDoc.GetPattern(
11301 aPos.Col(), aPos.Row(), aPos.Tab() );
11302 if ( pPattern )
11303 eCellLang = pPattern->GetItem( ATTR_LANGUAGE_FORMAT ).GetValue();
11304 else
11305 eCellLang = ScGlobal::eLnge;
11306 if (bString)
11307 {
11308 if (!mrContext.NFGetPreviewString( sFormatString, aStr.getString(),
11309 aResult, &pColor, eCellLang))
11310 PushIllegalArgument();
11311 else
11312 PushString( aResult);
11313 }
11314 else
11315 {
11316 if (!mrContext.NFGetPreviewStringGuess( sFormatString, fVal,
11317 aResult, &pColor, eCellLang))
11318 PushIllegalArgument();
11319 else
11320 PushString( aResult);
11321 }
11322 }
11323 }
11324
11325 void ScInterpreter::ScSubstitute()
11326 {
11327 sal_uInt8 nParamCount = GetByte();
11328 if ( !MustHaveParamCount( nParamCount, 3, 4 ) )
11329 return;
11330
11331 sal_Int32 nCnt;
11332 if (nParamCount == 4)
11333 {
11334 nCnt = GetStringPositionArgument();
11335 if (nCnt < 1)
11336 {
11337 PushIllegalArgument();
11338 return;
11339 }
11340 }
11341 else
11342 nCnt = 0;
11343 OUString sNewStr = GetString().getString();
11344 OUString sOldStr = GetString().getString();
11345 OUString sStr = GetString().getString();
11346 sal_Int32 nPos = 0;
11347 sal_Int32 nCount = 0;
11348 std::optional<OUStringBuffer> oResult;
11349 for (sal_Int32 nEnd = sStr.indexOf(sOldStr); nEnd >= 0; nEnd = sStr.indexOf(sOldStr, nEnd))
11350 {
11351 if (nCnt == 0 || ++nCount == nCnt) // Found a replacement cite
11352 {
11353 if (!oResult) // Only allocate buffer when needed
11354 oResult.emplace(sStr.getLength() + sNewStr.getLength() - sOldStr.getLength());
11355
11356 oResult->append(sStr.subView(nPos, nEnd - nPos)); // Copy leading unchanged text
11357 if (!CheckStringResultLen(*oResult, sNewStr.getLength()))
11358 return PushError(GetError());
11359 oResult->append(sNewStr); // Copy the replacement
11360 nPos = nEnd + sOldStr.getLength();
11361 if (nCnt > 0) // Found the single replacement site - end the loop
11362 break;
11363 }
11364 nEnd += sOldStr.getLength();
11365 }
11366 if (oResult) // If there were prior replacements, copy the rest, otherwise use original
11367 oResult->append(sStr.subView(nPos, sStr.getLength() - nPos));
11368 PushString(oResult ? oResult->makeStringAndClear() : sStr);
11369 }
11370
11371 void ScInterpreter::ScRept()
11372 {
11373 if ( !MustHaveParamCount( GetByte(), 2 ) )
11374 return;
11375
11376 sal_Int32 nCnt = GetStringPositionArgument();
11377 OUString aStr = GetString().getString();
11378 if (nCnt < 0)
11379 PushIllegalArgument();
11380 else if (static_cast<double>(nCnt) * aStr.getLength() > kScInterpreterMaxStrLen)
11381 {
11382 PushError( FormulaError::StringOverflow );
11383 }
11384 else if (nCnt == 0)
11385 PushString( OUString() );
11386 else
11387 {
11388 const sal_Int32 nLen = aStr.getLength();
11389 OUStringBuffer aRes(nCnt*nLen);
11390 while( nCnt-- )
11391 aRes.append(aStr);
11392 PushString( aRes.makeStringAndClear() );
11393 }
11394 }
11395
11396 void ScInterpreter::ScConcat()
11397 {
11398 sal_uInt8 nParamCount = GetByte();
11399
11400 //reverse order of parameter stack to simplify processing
11401 ReverseStack(nParamCount);
11402
11403 OUStringBuffer aRes;
11404 while( nParamCount-- > 0)
11405 {
11406 OUString aStr = GetString().getString();
11407 if (CheckStringResultLen(aRes, aStr.getLength()))
11408 aRes.append(aStr);
11409 else
11410 break;
11411 }
11412 PushString( aRes.makeStringAndClear() );
11413 }
11414
11415 FormulaError ScInterpreter::GetErrorType()
11416 {
11417 FormulaError nErr;
11418 FormulaError nOldError = nGlobalError;
11419 nGlobalError = FormulaError::NONE;
11420 switch ( GetStackType() )
11421 {
11422 case svRefList :
11423 {
11424 FormulaConstTokenRef x = PopToken();
11425 if (nGlobalError != FormulaError::NONE)
11426 nErr = nGlobalError;
11427 else
11428 {
11429 const ScRefList* pRefList = x->GetRefList();
11430 size_t n = pRefList->size();
11431 if (!n)
11432 nErr = FormulaError::NoRef;
11433 else if (n > 1)
11434 nErr = FormulaError::NoValue;
11435 else
11436 {
11437 ScRange aRange;
11438 DoubleRefToRange( (*pRefList)[0], aRange);
11439 if (nGlobalError != FormulaError::NONE)
11440 nErr = nGlobalError;
11441 else
11442 {
11443 ScAddress aAdr;
11444 if ( DoubleRefToPosSingleRef( aRange, aAdr ) )
11445 nErr = mrDoc.GetErrCode( aAdr );
11446 else
11447 nErr = nGlobalError;
11448 }
11449 }
11450 }
11451 }
11452 break;
11453 case svDoubleRef :
11454 {
11455 ScRange aRange;
11456 PopDoubleRef( aRange );
11457 if ( nGlobalError != FormulaError::NONE )
11458 nErr = nGlobalError;
11459 else
11460 {
11461 ScAddress aAdr;
11462 if ( DoubleRefToPosSingleRef( aRange, aAdr ) )
11463 nErr = mrDoc.GetErrCode( aAdr );
11464 else
11465 nErr = nGlobalError;
11466 }
11467 }
11468 break;
11469 case svSingleRef :
11470 {
11471 ScAddress aAdr;
11472 PopSingleRef( aAdr );
11473 if ( nGlobalError != FormulaError::NONE )
11474 nErr = nGlobalError;
11475 else
11476 nErr = mrDoc.GetErrCode( aAdr );
11477 }
11478 break;
11479 default:
11480 PopError();
11481 nErr = nGlobalError;
11482 }
11483 nGlobalError = nOldError;
11484 return nErr;
11485 }
11486
11487 void ScInterpreter::ScErrorType()
11488 {
11489 FormulaError nErr = GetErrorType();
11490 if ( nErr != FormulaError::NONE )
11491 {
11492 nGlobalError = FormulaError::NONE;
11493 PushDouble( static_cast<double>(nErr) );
11494 }
11495 else
11496 {
11497 PushNA();
11498 }
11499 }
11500
11501 void ScInterpreter::ScErrorType_ODF()
11502 {
11503 FormulaError nErr = GetErrorType();
11504 sal_uInt16 nErrType;
11505
11506 switch ( nErr )
11507 {
11508 case FormulaError::NoCode : // #NULL!
11509 nErrType = 1;
11510 break;
11511 case FormulaError::DivisionByZero : // #DIV/0!
11512 nErrType = 2;
11513 break;
11514 case FormulaError::NoValue : // #VALUE!
11515 nErrType = 3;
11516 break;
11517 case FormulaError::NoRef : // #REF!
11518 nErrType = 4;
11519 break;
11520 case FormulaError::NoName : // #NAME?
11521 nErrType = 5;
11522 break;
11523 case FormulaError::IllegalFPOperation : // #NUM!
11524 nErrType = 6;
11525 break;
11526 case FormulaError::NotAvailable : // #N/A
11527 nErrType = 7;
11528 break;
11529 /*
11530 #GETTING_DATA is a message that can appear in Excel when a large or
11531 complex worksheet is being calculated. In Excel 2007 and newer,
11532 operations are grouped so more complicated cells may finish after
11533 earlier ones do. While the calculations are still processing, the
11534 unfinished cells may display #GETTING_DATA.
11535 Because the message is temporary and disappears when the calculations
11536 complete, this isn’t a true error.
11537 No calc error code known (yet).
11538
11539 case : // GETTING_DATA
11540 nErrType = 8;
11541 break;
11542 */
11543 default :
11544 nErrType = 0;
11545 break;
11546 }
11547
11548 if ( nErrType )
11549 {
11550 nGlobalError =FormulaError::NONE;
11551 PushDouble( nErrType );
11552 }
11553 else
11554 PushNA();
11555 }
11556
11557 static bool MayBeRegExp( std::u16string_view rStr )
11558 {
11559 if ( rStr.empty() || (rStr.size() == 1 && rStr[0] != '.') )
11560 return false; // single meta characters can not be a regexp
11561 // First two characters are wildcard '?' and '*' characters.
11562 std::u16string_view cre(u"?*+.[]^$\\<>()|");
11563 return rStr.find_first_of(cre) != std::u16string_view::npos;
11564 }
11565
11566 static bool MayBeWildcard( std::u16string_view rStr )
11567 {
11568 // Wildcards with '~' escape, if there are no wildcards then an escaped
11569 // character does not make sense, but it modifies the search pattern in an
11570 // Excel compatible wildcard search...
11571 std::u16string_view cw(u"*?~");
11572 return rStr.find_first_of(cw) != std::u16string_view::npos;
11573 }
11574
11575 utl::SearchParam::SearchType ScInterpreter::DetectSearchType( std::u16string_view rStr, const ScDocument& rDoc )
11576 {
11577 const auto eType = rDoc.GetDocOptions().GetFormulaSearchType();
11578 if ((eType == utl::SearchParam::SearchType::Wildcard && MayBeWildcard(rStr))
11579 || (eType == utl::SearchParam::SearchType::Regexp && MayBeRegExp(rStr)))
11580 return eType;
11581 return utl::SearchParam::SearchType::Normal;
11582 }
11583
11584 bool ScInterpreter::SearchMatrixForValue( VectorSearchArguments& vsa, ScQueryParam& rParam, ScQueryEntry& rEntry, ScQueryEntry::Item& rItem )
11585 {
11586 SCSIZE nC, nR;
11587 vsa.pMatSrc->GetDimensions( nC, nR);
11588 if (nC > 1 && nR > 1)
11589 {
11590 // The source matrix must be a vector.
11591 PushIllegalParameter();
11592 return false;
11593 }
11594 vsa.bVLookup = ( nC == 1 );
11595
11596 // Do not propagate errors from matrix while searching.
11597 vsa.pMatSrc->SetErrorInterpreter( nullptr );
11598
11599 SCSIZE nMatCount = (vsa.bVLookup ? nR : nC);
11600 VectorMatrixAccessor aMatAcc(*(vsa.pMatSrc), vsa.bVLookup);
11601 bool bMatchWholeCell = mrDoc.GetDocOptions().IsMatchWholeCell();
11602
11603 switch ( vsa.eSearchMode )
11604 {
11605 case searchfwd :
11606 {
11607 switch ( vsa.eMatchMode )
11608 {
11609 case exactorNA :
11610 case wildcard :
11611 // simple serial search for equality mode (source data doesn't
11612 // need to be sorted).
11613 for (SCSIZE i = 0; i < nMatCount; ++i)
11614 {
11615 if (lcl_CompareMatrix2Query( i, aMatAcc, rParam, rEntry, bMatchWholeCell ) == 0)
11616 {
11617 vsa.nHitIndex = i+1; // found !
11618 break;
11619 }
11620 }
11621 break;
11622
11623 case exactorS :
11624 case exactorG :
11625 for (SCSIZE i = 0; i < nMatCount; ++i)
11626 {
11627 sal_Int32 result = lcl_CompareMatrix2Query( i, aMatAcc, rParam, rEntry, bMatchWholeCell );
11628 if (result == 0)
11629 {
11630 vsa.nHitIndex = i+1; // found !
11631 break;
11632 }
11633 else if (vsa.eMatchMode == exactorS && result == -1)
11634 {
11635 if ( vsa.nBestFit == SCSIZE_MAX )
11636 vsa.nBestFit = i;
11637 else
11638 {
11639 // replace value of vsa.nBestFit if value(i) > value(vsa.nBestFit)
11640 if ( lcl_Compare2MatrixCells( i, aMatAcc, vsa.nBestFit) == 1 )
11641 vsa.nBestFit = i;
11642 }
11643 }
11644 else if (vsa.eMatchMode == exactorG && result == 1)
11645 {
11646 if ( vsa.nBestFit == SCSIZE_MAX )
11647 vsa.nBestFit = i;
11648 else
11649 {
11650 // replace value of vsa.nBestFit if value(i) < value(vsa.nBestFit)
11651 if ( lcl_Compare2MatrixCells( i, aMatAcc, vsa.nBestFit) == -1 )
11652 vsa.nBestFit = i;
11653 }
11654 }
11655 // else do nothing
11656 }
11657 break;
11658
11659 default :
11660 PushIllegalParameter();
11661 return false;
11662 }
11663 }
11664 break;
11665
11666 case searchrev:
11667 {
11668 switch ( vsa.eMatchMode )
11669 {
11670 case exactorNA :
11671 case wildcard :
11672 // simple serial search for equality mode (source data doesn't
11673 // need to be sorted).
11674 for ( SCSIZE i = nMatCount - 1; i > 0; i-- )
11675 {
11676 if (lcl_CompareMatrix2Query(i, aMatAcc, rParam, rEntry, bMatchWholeCell) == 0)
11677 {
11678 vsa.nHitIndex = i + 1; // found !
11679 break;
11680 }
11681 }
11682 break;
11683
11684 case exactorS :
11685 case exactorG :
11686 for (SCSIZE i = nMatCount - 1; i-- > 0; )
11687 {
11688 sal_Int32 result = lcl_CompareMatrix2Query( i, aMatAcc, rParam, rEntry, bMatchWholeCell );
11689 if (result == 0)
11690 {
11691 vsa.nHitIndex = i + 1; // found !
11692 break;
11693 }
11694 else if (vsa.eMatchMode == exactorS && result == -1)
11695 {
11696 if ( vsa.nBestFit == SCSIZE_MAX )
11697 vsa.nBestFit = i;
11698 else
11699 {
11700 // replace value of vsa.nBestFit if value(i) > value(vsa.nBestFit)
11701 if ( lcl_Compare2MatrixCells( i, aMatAcc, vsa.nBestFit) == 1 )
11702 vsa.nBestFit = i;
11703 }
11704 }
11705 else if (vsa.eMatchMode == exactorG && result == 1)
11706 {
11707 if ( vsa.nBestFit == SCSIZE_MAX )
11708 vsa.nBestFit = i;
11709 else
11710 {
11711 // replace value of vsa.nBestFit if value(i) < value(vsa.nBestFit)
11712 if ( lcl_Compare2MatrixCells( i, aMatAcc, vsa.nBestFit) == -1 )
11713 vsa.nBestFit = i;
11714 }
11715 }
11716 // else do nothing
11717 }
11718 break;
11719
11720 default :
11721 PushIllegalParameter();
11722 return false;
11723 }
11724 }
11725 break;
11726
11727 case searchbasc:
11728 case searchbdesc:
11729 {
11730 // binary search for non-equality mode (the source data is sorted)
11731 bool bAscOrder = ( vsa.eSearchMode == searchbasc );
11732 SCSIZE nFirst = 0;
11733 SCSIZE nLast = nMatCount - 1;
11734 for ( SCSIZE nLen = nLast - nFirst; nLen > 0; nLen = nLast - nFirst )
11735 {
11736 SCSIZE nMid = nFirst + nLen / 2;
11737 sal_Int32 nCmp = lcl_CompareMatrix2Query( nMid, aMatAcc, rParam, rEntry, bMatchWholeCell );
11738 if ( nCmp == 0 )
11739 {
11740 // exact match. find the last item with the same value.
11741 lcl_GetLastMatch( nMid, aMatAcc, nMatCount);
11742 vsa.nHitIndex = nMid + 1;
11743 break;
11744 }
11745
11746 if ( nLen == 1 ) // first and last items are next to each other.
11747 {
11748 if ( bAscOrder && vsa.eMatchMode == exactorS )
11749 vsa.nHitIndex = ( nCmp > 0 ? nFirst : nLast );
11750 else if ( !bAscOrder && vsa.eMatchMode == exactorG )
11751 vsa.nHitIndex = ( nCmp < 0 ? nFirst : nLast );
11752 break;
11753 }
11754 else
11755 {
11756 if ( nCmp < 0 )
11757 {
11758 if ( bAscOrder )
11759 nFirst = nMid;
11760 else
11761 nLast = nMid;
11762 }
11763 else
11764 {
11765 if ( bAscOrder )
11766 nLast = nMid;
11767 else
11768 nFirst = nMid;
11769 }
11770
11771 if ( vsa.nHitIndex == nMatCount - 1 ) // last item
11772 {
11773 nCmp = lcl_CompareMatrix2Query( vsa.nHitIndex, aMatAcc, rParam, rEntry, bMatchWholeCell );
11774 if ( ( vsa.eMatchMode == exactorS && nCmp <= 0 ) ||
11775 ( vsa.eMatchMode == exactorG && nCmp >= 0 ) )
11776 {
11777 // either the last item is an exact match or the real
11778 // hit is beyond the last item.
11779 vsa.nHitIndex++;
11780 }
11781 else
11782 vsa.nHitIndex = 0;
11783 }
11784 }
11785 }
11786 }
11787 break;
11788
11789 default:
11790 PushIllegalParameter();
11791 return false;
11792 }
11793
11794 if ((vsa.nHitIndex > 0) && ((rItem.meType == ScQueryEntry::ByString && aMatAcc.IsValue(vsa.nHitIndex - 1)) ||
11795 (rItem.meType == ScQueryEntry::ByValue && !aMatAcc.IsValue(vsa.nHitIndex - 1))))
11796 {
11797 vsa.nHitIndex = 0;
11798 vsa.isResultNA = true;
11799 return false;
11800 }
11801 return true;
11802 }
11803
11804 bool ScInterpreter::SearchRangeForValue( VectorSearchArguments& vsa, ScQueryParam& rParam, ScQueryEntry& rEntry )
11805 {
11806 vsa.bVLookup = ( vsa.nCol1 == vsa.nCol2 );
11807 switch ( vsa.eSearchMode )
11808 {
11809 case searchfwd:
11810 case searchrev:
11811 case searchbasc:
11812 case searchbdesc:
11813 {
11814 if (vsa.bVLookup)
11815 {
11816 // search of rows in column
11817 rParam.bByRow = true;
11818 ScAddress aResultPos( vsa.nCol1, vsa.nRow1, vsa.nTab1 );
11819 const ScComplexRefData* refData = nullptr;
11820 if ( LookupQueryWithCache( aResultPos, rParam, refData, vsa.eSearchMode, vsa.nSearchOpCode ) )
11821 vsa.nHitIndex = aResultPos.Row() - vsa.nRow1 + 1;
11822 }
11823 else
11824 {
11825 rParam.bByRow = false;
11826 bool bBinarySearch = vsa.eSearchMode == searchbasc || vsa.eSearchMode == searchbdesc;
11827 if (bBinarySearch && (vsa.nSearchOpCode == SC_OPCODE_X_LOOKUP || vsa.nSearchOpCode == SC_OPCODE_X_MATCH))
11828 {
11829 ScQueryCellIteratorSortedCache aCellIter(mrDoc, mrContext, rParam.nTab, rParam, false, false);
11830 // Advance Entry.nField in Iterator if column changed
11831 aCellIter.SetAdvanceQueryParamEntryField(true);
11832 aCellIter.SetSortedBinarySearchMode(vsa.eSearchMode);
11833 aCellIter.SetLookupMode(vsa.nSearchOpCode);
11834 if (aCellIter.GetFirst())
11835 {
11836 vsa.nHitIndex = aCellIter.GetCol() - vsa.nCol1 + 1;
11837 }
11838 }
11839 else
11840 {
11841 // search of columns in row
11842 bool bReverseSearch = (vsa.eSearchMode == searchrev);
11843 ScQueryCellIteratorDirect aCellIter(mrDoc, mrContext, vsa.nTab1, rParam, false, bReverseSearch);
11844 // Advance Entry.nField in Iterator if column changed
11845 aCellIter.SetAdvanceQueryParamEntryField(true);
11846 aCellIter.SetLookupMode(vsa.nSearchOpCode);
11847 aCellIter.SetSortedBinarySearchMode(vsa.eSearchMode);
11848 if (rEntry.eOp == SC_EQUAL)
11849 {
11850 if (aCellIter.GetFirst())
11851 vsa.nHitIndex = aCellIter.GetCol() - vsa.nCol1 + 1;
11852 }
11853 else
11854 {
11855 SCCOL nC;
11856 SCROW nR;
11857 if (aCellIter.FindEqualOrSortedLastInRange(nC, nR))
11858 vsa.nHitIndex = nC - vsa.nCol1 + 1;
11859 }
11860 }
11861 }
11862 }
11863 break;
11864
11865 default :
11866 PushIllegalParameter();
11867 return false;
11868 }
11869 return true;
11870 }
11871
11872
11873 /** When search value is found, the index is stored in struct VectorSearchArguments.nIndex
11874 and SearchVectorForValue() returns true. When search value is not found or an error
11875 occurs, SearchVectorForValue() pushes the relevant (error)message and returns false,
11876 expect when SearchVectorForValue() is called by ScXLookup and the search value is not
11877 found.
11878 This difference in behaviour is because MATCH returns the found index and XLOOKUP
11879 uses the found index to determine the result(s) to be pushed and may return a custom
11880 value when the search value is not found.
11881 */
11882 bool ScInterpreter::SearchVectorForValue( VectorSearchArguments& vsa )
11883 {
11884 // preparations
11885 ScQueryParam rParam;
11886 rParam.nCol1 = vsa.nCol1;
11887 rParam.nRow1 = vsa.nRow1;
11888 rParam.nCol2 = vsa.nCol2;
11889 rParam.nRow2 = vsa.nRow2;
11890 rParam.nTab = vsa.nTab1;
11891
11892 ScQueryEntry& rEntry = rParam.GetEntry(0);
11893 rEntry.nField = vsa.eSearchMode != searchrev ? vsa.nCol1 : vsa.nCol2;
11894 rEntry.bDoQuery = true;
11895 switch ( vsa.eMatchMode )
11896 {
11897 case exactorNA :
11898 rEntry.eOp = SC_EQUAL;
11899 break;
11900
11901 case exactorS :
11902 rEntry.eOp = SC_LESS_EQUAL;
11903 break;
11904
11905 case exactorG :
11906 rEntry.eOp = SC_GREATER_EQUAL;
11907 break;
11908
11909 case wildcard :
11910 case regex :
11911 // this mode can only used with XLOOKUP/XMATCH
11912 if ( vsa.nSearchOpCode == SC_OPCODE_X_LOOKUP || vsa.nSearchOpCode == SC_OPCODE_X_MATCH )
11913 {
11914 // Wildcard/Regex search mode with binary search is not allowed
11915 if (vsa.eSearchMode == searchbasc || vsa.eSearchMode == searchbdesc)
11916 {
11917 PushNoValue();
11918 return false;
11919 }
11920
11921 rEntry.eOp = SC_EQUAL;
11922 if ( vsa.isStringSearch )
11923 {
11924 if (vsa.eMatchMode == wildcard && MayBeWildcard(vsa.sSearchStr.getString()))
11925 rParam.eSearchType = utl::SearchParam::SearchType::Wildcard;
11926 else if (vsa.eMatchMode == regex && MayBeRegExp(vsa.sSearchStr.getString()))
11927 rParam.eSearchType = utl::SearchParam::SearchType::Regexp;
11928 else
11929 rParam.eSearchType = utl::SearchParam::SearchType::Normal;
11930 }
11931 }
11932 else
11933 {
11934 PushIllegalParameter();
11935 return false;
11936 }
11937 break;
11938
11939 default :
11940 PushIllegalParameter();
11941 return false;
11942 }
11943
11944 ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
11945 // allow to match empty cells as result if we are looking for the next smaller
11946 // or larger values in case of the new lookup functions
11947 if (rEntry.eOp != SC_EQUAL && (vsa.nSearchOpCode == SC_OPCODE_X_LOOKUP ||
11948 vsa.nSearchOpCode == SC_OPCODE_X_MATCH))
11949 rItem.mbMatchEmpty = true;
11950
11951 if ( vsa.isStringSearch )
11952 {
11953 rItem.meType = ScQueryEntry::ByString;
11954 rItem.maString = vsa.sSearchStr;
11955 if ( vsa.nSearchOpCode == SC_OPCODE_MATCH )
11956 {
11957 if ( mrDoc.IsInVBAMode() )
11958 rParam.eSearchType = utl::SearchParam::SearchType::Wildcard;
11959 else
11960 rParam.eSearchType = DetectSearchType(rEntry.GetQueryItem().maString.getString(), mrDoc);
11961 }
11962 }
11963 else if ( vsa.isEmptySearch && (vsa.nSearchOpCode == SC_OPCODE_X_LOOKUP ||
11964 vsa.nSearchOpCode == SC_OPCODE_X_MATCH) )
11965 {
11966 rEntry.SetQueryByEmpty();
11967 rItem.mbMatchEmpty = true;
11968 }
11969 else
11970 {
11971 rItem.mfVal = vsa.fSearchVal;
11972 rItem.meType = ScQueryEntry::ByValue;
11973 }
11974
11975 // execute search
11976 if (vsa.pMatSrc) // The source data is matrix array.
11977 {
11978 // matrix
11979 if ( !SearchMatrixForValue( vsa, rParam, rEntry, rItem ) )
11980 return false;
11981 }
11982 else
11983 {
11984 // not a matrix
11985 if ( !SearchRangeForValue( vsa, rParam, rEntry ) )
11986 return false;
11987 }
11988
11989 // MATCH expects index starting with 1, XLOOKUP expects index starting with 0
11990 if ( vsa.nHitIndex > 0 )
11991 {
11992 vsa.nIndex = ( vsa.nSearchOpCode == SC_OPCODE_X_LOOKUP ? --vsa.nHitIndex : vsa.nHitIndex );
11993 return true;
11994 }
11995 else if ( vsa.nHitIndex == 0 && vsa.nBestFit != SCSIZE_MAX )
11996 {
11997 if ( vsa.nSearchOpCode == SC_OPCODE_X_LOOKUP )
11998 {
11999 vsa.nIndex = vsa.nBestFit;
12000 if ( !vsa.pMatSrc )
12001 {
12002 vsa.nIndex -= ( vsa.bVLookup ? vsa.nRow1 : vsa.nCol1 );
12003 }
12004 }
12005 else
12006 {
12007 vsa.nIndex = ++vsa.nBestFit;
12008 }
12009 return true;
12010 }
12011
12012 // nomatch
12013 vsa.isResultNA = true;
12014 return false;
12015 }
12016
12017 static bool lcl_LookupQuery( ScAddress & o_rResultPos, ScDocument& rDoc, ScInterpreterContext& rContext,
12018 const ScQueryParam & rParam, const ScQueryEntry & rEntry, const ScFormulaCell* cell,
12019 const ScComplexRefData* refData, sal_Int8 nSearchMode, sal_uInt16 nOpCode )
12020 {
12021 if (rEntry.eOp != SC_EQUAL)
12022 {
12023 // range lookup <= or >=
12024 SCCOL nCol;
12025 SCROW nRow;
12026 bool bBinarySearch = static_cast<SearchMode>(nSearchMode) == searchbasc || static_cast<SearchMode>(nSearchMode) == searchbdesc;
12027 if ((bBinarySearch && (nOpCode == SC_OPCODE_X_LOOKUP || nOpCode == SC_OPCODE_X_MATCH)) ||
12028 ScQueryCellIteratorSortedCache::CanBeUsed(rDoc, rParam, rParam.nTab, cell, refData, rContext))
12029 {
12030 ScQueryCellIteratorSortedCache aCellIter(rDoc, rContext, rParam.nTab, rParam, false, false);
12031 aCellIter.SetSortedBinarySearchMode(nSearchMode);
12032 aCellIter.SetLookupMode(nOpCode);
12033 if (aCellIter.GetFirst())
12034 {
12035 o_rResultPos.SetCol(aCellIter.GetCol());
12036 o_rResultPos.SetRow(aCellIter.GetRow());
12037 return true;
12038 }
12039 }
12040 else
12041 {
12042 bool bReverse = (static_cast<SearchMode>(nSearchMode) == searchrev);
12043 ScQueryCellIteratorDirect aCellIter(rDoc, rContext, rParam.nTab, rParam, false, bReverse);
12044
12045 aCellIter.SetSortedBinarySearchMode(nSearchMode);
12046 aCellIter.SetLookupMode(nOpCode);
12047 if (aCellIter.FindEqualOrSortedLastInRange(nCol, nRow))
12048 {
12049 o_rResultPos.SetCol(nCol);
12050 o_rResultPos.SetRow(nRow);
12051 return true;
12052 }
12053 }
12054 }
12055 else // EQUAL
12056 {
12057 // we can use binary search for rows if the SearchMode is searchbasc or searchbdesc
12058 bool bLiteral = rParam.eSearchType == utl::SearchParam::SearchType::Normal &&
12059 rEntry.GetQueryItem().meType == ScQueryEntry::ByString;
12060 bool bBinary = rParam.bByRow &&
12061 (bLiteral || rEntry.GetQueryItem().meType == ScQueryEntry::ByValue);
12062
12063 if( bBinary && (static_cast<SearchMode>(nSearchMode) == searchbasc || static_cast<SearchMode>(nSearchMode) == searchbdesc ||
12064 ScQueryCellIteratorSortedCache::CanBeUsed(rDoc, rParam, rParam.nTab, cell, refData, rContext)))
12065 {
12066 ScQueryCellIteratorSortedCache aCellIter( rDoc, rContext, rParam.nTab, rParam, false, false );
12067 aCellIter.SetSortedBinarySearchMode(nSearchMode);
12068 aCellIter.SetLookupMode(nOpCode);
12069 if (aCellIter.GetFirst())
12070 {
12071 o_rResultPos.SetCol( aCellIter.GetCol());
12072 o_rResultPos.SetRow( aCellIter.GetRow());
12073 return true;
12074 }
12075 }
12076 else
12077 {
12078 ScQueryCellIteratorDirect aCellIter( rDoc, rContext, rParam.nTab, rParam, false,
12079 static_cast<SearchMode>(nSearchMode) == searchrev);
12080 aCellIter.SetSortedBinarySearchMode(nSearchMode);
12081 aCellIter.SetLookupMode(nOpCode);
12082 if (aCellIter.GetFirst())
12083 {
12084 o_rResultPos.SetCol( aCellIter.GetCol());
12085 o_rResultPos.SetRow( aCellIter.GetRow());
12086 return true;
12087 }
12088 }
12089 }
12090 return false;
12091 }
12092
12093 // tdf#121052:
12094 // =VLOOKUP(SearchCriterion; RangeArray; Index; Sorted)
12095 // [SearchCriterion] is the value searched for in the first column of the array.
12096 // [RangeArray] is the reference, which is to comprise at least two columns.
12097 // [Index] is the number of the column in the array that contains the value to be returned. The first column has the number 1.
12098 //
12099 // Prerequisite of lcl_getPrevRowWithEmptyValueLookup():
12100 // Value referenced by [SearchCriterion] is empty.
12101 // lcl_getPrevRowWithEmptyValueLookup() performs following checks:
12102 // - if we run query with "exact match" mode (i.e. VLOOKUP)
12103 // - and if we already have the same lookup done before but for another row
12104 // which is also had empty [SearchCriterion]
12105 //
12106 // then
12107 // we could say, that for current row we could reuse results of the cached call which was done for the row2
12108 // In this case we return row index, which is >= 0.
12109 //
12110 // Elsewhere
12111 // -1 is returned, which will lead to default behavior =>
12112 // complete lookup will be done in RangeArray inside lcl_LookupQuery() method.
12113 //
12114 // This method was added only for speed up to avoid several useless complete
12115 // lookups inside [RangeArray] for searching empty strings.
12116 //
12117 static SCROW lcl_getPrevRowWithEmptyValueLookup( const ScLookupCache& rCache,
12118 const ScLookupCache::QueryCriteria& rCriteria, const ScQueryParam & rParam)
12119 {
12120 // is lookup value empty?
12121 const ScQueryEntry& rEntry = rParam.GetEntry(0);
12122 const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
12123 if (! rItem.maString.getString().isEmpty())
12124 return -1; // not found
12125
12126 // try to find the row index for which we have already performed lookup
12127 // and have some result of it inside cache
12128 return rCache.lookup( rCriteria );
12129 }
12130
12131 bool ScInterpreter::LookupQueryWithCache( ScAddress & o_rResultPos,
12132 const ScQueryParam & rParam, const ScComplexRefData* refData,
12133 sal_Int8 nSearchMode, sal_uInt16 nOpCode ) const
12134 {
12135 bool bFound = false;
12136 const ScQueryEntry& rEntry = rParam.GetEntry(0);
12137 bool bColumnsMatch = (rParam.nCol1 == rEntry.nField);
12138 // At least all volatile functions that generate indirect references have
12139 // to force non-cached lookup.
12140 /* TODO: We could further classify volatile functions into reference
12141 * generating and not reference generating functions to have to force less
12142 * direct lookups here. We could even further attribute volatility per
12143 * parameter so it would affect only the lookup range parameter. */
12144 if (!bColumnsMatch || GetVolatileType() != NOT_VOLATILE)
12145 bFound = lcl_LookupQuery( o_rResultPos, mrDoc, mrContext, rParam, rEntry, pMyFormulaCell,
12146 refData, nSearchMode, nOpCode );
12147 else
12148 {
12149 ScRange aLookupRange( rParam.nCol1, rParam.nRow1, rParam.nTab,
12150 rParam.nCol2, rParam.nRow2, rParam.nTab);
12151 ScLookupCache& rCache = mrDoc.GetLookupCache( aLookupRange, &mrContext );
12152 ScLookupCache::QueryCriteria aCriteria( rEntry );
12153 ScLookupCache::Result eCacheResult = rCache.lookup( o_rResultPos,
12154 aCriteria, aPos);
12155
12156 // tdf#121052: Slow load of cells with VLOOKUP with references to empty cells
12157 // This check was added only for speed up to avoid several useless complete
12158 // lookups inside [RangeArray] for searching empty strings.
12159 if (eCacheResult == ScLookupCache::NOT_CACHED && aCriteria.isEmptyStringQuery())
12160 {
12161 const SCROW nPrevRowWithEmptyValueLookup = lcl_getPrevRowWithEmptyValueLookup(rCache, aCriteria, rParam);
12162 if (nPrevRowWithEmptyValueLookup >= 0)
12163 {
12164 // make the same lookup using cache with different row index
12165 // (this lookup was already cached)
12166 ScAddress aPosPrev(aPos);
12167 aPosPrev.SetRow(nPrevRowWithEmptyValueLookup);
12168
12169 eCacheResult = rCache.lookup( o_rResultPos, aCriteria, aPosPrev );
12170 }
12171 }
12172
12173 switch (eCacheResult)
12174 {
12175 case ScLookupCache::NOT_CACHED :
12176 case ScLookupCache::CRITERIA_DIFFERENT :
12177 bFound = lcl_LookupQuery( o_rResultPos, mrDoc, mrContext, rParam, rEntry,
12178 pMyFormulaCell, refData, nSearchMode, nOpCode );
12179 if (eCacheResult == ScLookupCache::NOT_CACHED)
12180 rCache.insert( o_rResultPos, aCriteria, aPos, bFound);
12181 break;
12182 case ScLookupCache::FOUND :
12183 bFound = true;
12184 break;
12185 case ScLookupCache::NOT_AVAILABLE :
12186 ; // nothing, bFound remains FALSE
12187 break;
12188 }
12189 }
12190 return bFound;
12191 }
12192
12193 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE