LibreOffice Module sc (master)  1
interpr4.cxx
Go to the documentation of this file.
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 <config_features.h>
21 
22 #include <interpre.hxx>
23 
24 #include <o3tl/safeint.hxx>
25 #include <rtl/math.hxx>
26 #include <sfx2/app.hxx>
27 #include <sfx2/objsh.hxx>
28 #include <basic/sbmeth.hxx>
29 #include <basic/sbmod.hxx>
30 #include <basic/sbstar.hxx>
31 #include <basic/sbx.hxx>
32 #include <basic/sbxobj.hxx>
33 #include <basic/sbuno.hxx>
34 #include <svl/zforlist.hxx>
35 #include <svl/sharedstringpool.hxx>
36 #include <unotools/charclass.hxx>
37 #include <stdlib.h>
38 #include <string.h>
39 
40 #include <com/sun/star/table/XCellRange.hpp>
41 #include <com/sun/star/script/XInvocation.hpp>
42 #include <com/sun/star/sheet/XSheetCellRange.hpp>
43 
44 #include <global.hxx>
45 #include <dbdata.hxx>
46 #include <formulacell.hxx>
47 #include <callform.hxx>
48 #include <addincol.hxx>
49 #include <document.hxx>
50 #include <dociter.hxx>
51 #include <docoptio.hxx>
52 #include <scmatrix.hxx>
53 #include <adiasync.hxx>
54 #include <cellsuno.hxx>
55 #include <optuno.hxx>
56 #include <rangeseq.hxx>
57 #include <addinlis.hxx>
58 #include <jumpmatrix.hxx>
59 #include <parclass.hxx>
60 #include <externalrefmgr.hxx>
61 #include <formula/FormulaCompiler.hxx>
62 #include <macromgr.hxx>
63 #include <doubleref.hxx>
64 #include <queryparam.hxx>
65 #include <tokenarray.hxx>
66 #include <compiler.hxx>
67 
68 #include <map>
69 #include <algorithm>
70 #include <basic/basmgr.hxx>
71 #include <vbahelper/vbaaccesshelper.hxx>
72 #include <memory>
73 
74 using namespace com::sun::star;
75 using namespace formula;
76 using ::std::unique_ptr;
77 
78 #define ADDIN_MAXSTRLEN 256
79 
80 thread_local std::unique_ptr<ScTokenStack> ScInterpreter::pGlobalStack;
81 thread_local bool ScInterpreter::bGlobalStackInUse = false;
82 
83 // document access functions
84 
85 void ScInterpreter::ReplaceCell( ScAddress& rPos )
86 {
87  size_t ListSize = mrDoc.m_TableOpList.size();
88  for ( size_t i = 0; i < ListSize; ++i )
89  {
90  ScInterpreterTableOpParams *const pTOp = mrDoc.m_TableOpList[ i ];
91  if ( rPos == pTOp->aOld1 )
92  {
93  rPos = pTOp->aNew1;
94  return ;
95  }
96  else if ( rPos == pTOp->aOld2 )
97  {
98  rPos = pTOp->aNew2;
99  return ;
100  }
101  }
102 }
103 
104 bool ScInterpreter::IsTableOpInRange( const ScRange& rRange )
105 {
106  if ( rRange.aStart == rRange.aEnd )
107  return false; // not considered to be a range in TableOp sense
108 
109  // we can't replace a single cell in a range
110  size_t ListSize = mrDoc.m_TableOpList.size();
111  for ( size_t i = 0; i < ListSize; ++i )
112  {
113  ScInterpreterTableOpParams *const pTOp = mrDoc.m_TableOpList[ i ];
114  if ( rRange.In( pTOp->aOld1 ) )
115  return true;
116  if ( rRange.In( pTOp->aOld2 ) )
117  return true;
118  }
119  return false;
120 }
121 
122 sal_uInt32 ScInterpreter::GetCellNumberFormat( const ScAddress& rPos, ScRefCellValue& rCell )
123 {
124  sal_uInt32 nFormat;
125  FormulaError nErr;
126  if (rCell.isEmpty())
127  {
128  nFormat = mrDoc.GetNumberFormat( mrContext, rPos );
129  nErr = FormulaError::NONE;
130  }
131  else
132  {
133  if (rCell.meType == CELLTYPE_FORMULA)
134  nErr = rCell.mpFormula->GetErrCode();
135  else
136  nErr = FormulaError::NONE;
137  nFormat = mrDoc.GetNumberFormat( mrContext, rPos );
138  }
139 
140  SetError(nErr);
141  return nFormat;
142 }
143 
145 double ScInterpreter::GetValueCellValue( const ScAddress& rPos, double fOrig )
146 {
147  if ( bCalcAsShown && fOrig != 0.0 )
148  {
149  sal_uInt32 nFormat = mrDoc.GetNumberFormat( mrContext, rPos );
150  fOrig = mrDoc.RoundValueAsShown( fOrig, nFormat, &mrContext );
151  }
152  return fOrig;
153 }
154 
155 FormulaError ScInterpreter::GetCellErrCode( const ScRefCellValue& rCell )
156 {
157  return rCell.meType == CELLTYPE_FORMULA ? rCell.mpFormula->GetErrCode() : FormulaError::NONE;
158 }
159 
160 double ScInterpreter::ConvertStringToValue( const OUString& rStr )
161 {
162  FormulaError nError = FormulaError::NONE;
163  double fValue = ScGlobal::ConvertStringToValue( rStr, maCalcConfig, nError, mnStringNoValueError,
164  pFormatter, nCurFmtType);
165  if (nError != FormulaError::NONE)
166  SetError(nError);
167  return fValue;
168 }
169 
170 double ScInterpreter::ConvertStringToValue( const OUString& rStr, FormulaError& rError, SvNumFormatType& rCurFmtType )
171 {
172  return ScGlobal::ConvertStringToValue( rStr, maCalcConfig, rError, mnStringNoValueError, pFormatter, rCurFmtType);
173 }
174 
175 double ScInterpreter::GetCellValue( const ScAddress& rPos, ScRefCellValue& rCell )
176 {
177  FormulaError nErr = nGlobalError;
178  nGlobalError = FormulaError::NONE;
179  double nVal = GetCellValueOrZero(rPos, rCell);
180  if ( nGlobalError == FormulaError::NONE || nGlobalError == FormulaError::CellNoValue )
181  nGlobalError = nErr;
182  return nVal;
183 }
184 
185 double ScInterpreter::GetCellValueOrZero( const ScAddress& rPos, ScRefCellValue& rCell )
186 {
187  double fValue = 0.0;
188 
189  CellType eType = rCell.meType;
190  switch (eType)
191  {
192  case CELLTYPE_FORMULA:
193  {
194  ScFormulaCell* pFCell = rCell.mpFormula;
195  FormulaError nErr = pFCell->GetErrCode();
196  if( nErr == FormulaError::NONE )
197  {
198  if (pFCell->IsValue())
199  {
200  fValue = pFCell->GetValue();
201  mrDoc.GetNumberFormatInfo( mrContext, nCurFmtType, nCurFmtIndex,
202  rPos );
203  }
204  else
205  {
206  fValue = ConvertStringToValue(pFCell->GetString().getString());
207  }
208  }
209  else
210  {
211  fValue = 0.0;
212  SetError(nErr);
213  }
214  }
215  break;
216  case CELLTYPE_VALUE:
217  {
218  fValue = rCell.mfValue;
219  nCurFmtIndex = mrDoc.GetNumberFormat( mrContext, rPos );
220  nCurFmtType = mrContext.GetNumberFormatType( nCurFmtIndex );
221  if ( bCalcAsShown && fValue != 0.0 )
222  fValue = mrDoc.RoundValueAsShown( fValue, nCurFmtIndex, &mrContext );
223  }
224  break;
225  case CELLTYPE_STRING:
226  case CELLTYPE_EDIT:
227  {
228  // SUM(A1:A2) differs from A1+A2. No good. But people insist on
229  // it ... #i5658#
230  OUString aStr = rCell.getString(&mrDoc);
231  fValue = ConvertStringToValue( aStr );
232  }
233  break;
234  case CELLTYPE_NONE:
235  fValue = 0.0; // empty or broadcaster cell
236  break;
237  }
238 
239  return fValue;
240 }
241 
242 void ScInterpreter::GetCellString( svl::SharedString& rStr, ScRefCellValue& rCell )
243 {
244  FormulaError nErr = FormulaError::NONE;
245 
246  switch (rCell.meType)
247  {
248  case CELLTYPE_STRING:
249  case CELLTYPE_EDIT:
250  rStr = mrStrPool.intern(rCell.getString(&mrDoc));
251  break;
252  case CELLTYPE_FORMULA:
253  {
254  ScFormulaCell* pFCell = rCell.mpFormula;
255  nErr = pFCell->GetErrCode();
256  if (pFCell->IsValue())
257  {
258  rStr = GetStringFromDouble( pFCell->GetValue() );
259  }
260  else
261  rStr = pFCell->GetString();
262  }
263  break;
264  case CELLTYPE_VALUE:
265  {
266  rStr = GetStringFromDouble( rCell.mfValue );
267  }
268  break;
269  default:
270  rStr = svl::SharedString::getEmptyString();
271  break;
272  }
273 
274  SetError(nErr);
275 }
276 
277 bool ScInterpreter::CreateDoubleArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
278  SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8* pCellArr)
279 {
280 
281  // Old Add-Ins are hard limited to sal_uInt16 values.
282  static_assert(MAXCOLCOUNT <= SAL_MAX_UINT16, "Add check for columns > SAL_MAX_UINT16!");
283  if (nRow1 > SAL_MAX_UINT16 || nRow2 > SAL_MAX_UINT16)
284  return false;
285 
286  sal_uInt16 nCount = 0;
287  sal_uInt16* p = reinterpret_cast<sal_uInt16*>(pCellArr);
288  *p++ = static_cast<sal_uInt16>(nCol1);
289  *p++ = static_cast<sal_uInt16>(nRow1);
290  *p++ = static_cast<sal_uInt16>(nTab1);
291  *p++ = static_cast<sal_uInt16>(nCol2);
292  *p++ = static_cast<sal_uInt16>(nRow2);
293  *p++ = static_cast<sal_uInt16>(nTab2);
294  sal_uInt16* pCount = p;
295  *p++ = 0;
296  sal_uInt16 nPos = 14;
297  SCTAB nTab = nTab1;
298  ScAddress aAdr;
299  while (nTab <= nTab2)
300  {
301  aAdr.SetTab( nTab );
302  SCROW nRow = nRow1;
303  while (nRow <= nRow2)
304  {
305  aAdr.SetRow( nRow );
306  SCCOL nCol = nCol1;
307  while (nCol <= nCol2)
308  {
309  aAdr.SetCol( nCol );
310 
311  ScRefCellValue aCell(mrDoc, aAdr);
312  if (!aCell.isEmpty())
313  {
314  FormulaError nErr = FormulaError::NONE;
315  double nVal = 0.0;
316  bool bOk = true;
317  switch (aCell.meType)
318  {
319  case CELLTYPE_VALUE :
320  nVal = GetValueCellValue(aAdr, aCell.mfValue);
321  break;
322  case CELLTYPE_FORMULA :
323  if (aCell.mpFormula->IsValue())
324  {
325  nErr = aCell.mpFormula->GetErrCode();
326  nVal = aCell.mpFormula->GetValue();
327  }
328  else
329  bOk = false;
330  break;
331  default :
332  bOk = false;
333  break;
334  }
335  if (bOk)
336  {
337  if ((nPos + (4 * sizeof(sal_uInt16)) + sizeof(double)) > MAXARRSIZE)
338  return false;
339  *p++ = static_cast<sal_uInt16>(nCol);
340  *p++ = static_cast<sal_uInt16>(nRow);
341  *p++ = static_cast<sal_uInt16>(nTab);
342  *p++ = static_cast<sal_uInt16>(nErr);
343  memcpy( p, &nVal, sizeof(double));
344  nPos += 8 + sizeof(double);
345  p = reinterpret_cast<sal_uInt16*>( pCellArr + nPos );
346  nCount++;
347  }
348  }
349  nCol++;
350  }
351  nRow++;
352  }
353  nTab++;
354  }
355  *pCount = nCount;
356  return true;
357 }
358 
359 bool ScInterpreter::CreateStringArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
360  SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
361  sal_uInt8* pCellArr)
362 {
363 
364  // Old Add-Ins are hard limited to sal_uInt16 values.
365  static_assert(MAXCOLCOUNT <= SAL_MAX_UINT16, "Add check for columns > SAL_MAX_UINT16!");
366  if (nRow1 > SAL_MAX_UINT16 || nRow2 > SAL_MAX_UINT16)
367  return false;
368 
369  sal_uInt16 nCount = 0;
370  sal_uInt16* p = reinterpret_cast<sal_uInt16*>(pCellArr);
371  *p++ = static_cast<sal_uInt16>(nCol1);
372  *p++ = static_cast<sal_uInt16>(nRow1);
373  *p++ = static_cast<sal_uInt16>(nTab1);
374  *p++ = static_cast<sal_uInt16>(nCol2);
375  *p++ = static_cast<sal_uInt16>(nRow2);
376  *p++ = static_cast<sal_uInt16>(nTab2);
377  sal_uInt16* pCount = p;
378  *p++ = 0;
379  sal_uInt16 nPos = 14;
380  SCTAB nTab = nTab1;
381  while (nTab <= nTab2)
382  {
383  SCROW nRow = nRow1;
384  while (nRow <= nRow2)
385  {
386  SCCOL nCol = nCol1;
387  while (nCol <= nCol2)
388  {
389  ScRefCellValue aCell(mrDoc, ScAddress(nCol, nRow, nTab));
390  if (!aCell.isEmpty())
391  {
392  OUString aStr;
393  FormulaError nErr = FormulaError::NONE;
394  bool bOk = true;
395  switch (aCell.meType)
396  {
397  case CELLTYPE_STRING:
398  case CELLTYPE_EDIT:
399  aStr = aCell.getString(&mrDoc);
400  break;
401  case CELLTYPE_FORMULA:
402  if (!aCell.mpFormula->IsValue())
403  {
404  nErr = aCell.mpFormula->GetErrCode();
405  aStr = aCell.mpFormula->GetString().getString();
406  }
407  else
408  bOk = false;
409  break;
410  default :
411  bOk = false;
412  break;
413  }
414  if (bOk)
415  {
416  OString aTmp(OUStringToOString(aStr,
417  osl_getThreadTextEncoding()));
418  // Old Add-Ins are limited to sal_uInt16 string
419  // lengths, and room for pad byte check.
420  if ( aTmp.getLength() > SAL_MAX_UINT16 - 2 )
421  return false;
422  // Append a 0-pad-byte if string length is odd
423  // MUST be sal_uInt16
424  sal_uInt16 nStrLen = static_cast<sal_uInt16>(aTmp.getLength());
425  sal_uInt16 nLen = ( nStrLen + 2 ) & ~1;
426 
427  if ((static_cast<sal_uLong>(nPos) + (5 * sizeof(sal_uInt16)) + nLen) > MAXARRSIZE)
428  return false;
429  *p++ = static_cast<sal_uInt16>(nCol);
430  *p++ = static_cast<sal_uInt16>(nRow);
431  *p++ = static_cast<sal_uInt16>(nTab);
432  *p++ = static_cast<sal_uInt16>(nErr);
433  *p++ = nLen;
434  memcpy( p, aTmp.getStr(), nStrLen + 1);
435  nPos += 10 + nStrLen + 1;
436  sal_uInt8* q = pCellArr + nPos;
437  if( (nStrLen & 1) == 0 )
438  {
439  *q++ = 0;
440  nPos++;
441  }
442  p = reinterpret_cast<sal_uInt16*>( pCellArr + nPos );
443  nCount++;
444  }
445  }
446  nCol++;
447  }
448  nRow++;
449  }
450  nTab++;
451  }
452  *pCount = nCount;
453  return true;
454 }
455 
456 bool ScInterpreter::CreateCellArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
457  SCCOL nCol2, SCROW nRow2, SCTAB nTab2,
458  sal_uInt8* pCellArr)
459 {
460 
461  // Old Add-Ins are hard limited to sal_uInt16 values.
462  static_assert(MAXCOLCOUNT <= SAL_MAX_UINT16, "Add check for columns > SAL_MAX_UINT16!");
463  if (nRow1 > SAL_MAX_UINT16 || nRow2 > SAL_MAX_UINT16)
464  return false;
465 
466  sal_uInt16 nCount = 0;
467  sal_uInt16* p = reinterpret_cast<sal_uInt16*>(pCellArr);
468  *p++ = static_cast<sal_uInt16>(nCol1);
469  *p++ = static_cast<sal_uInt16>(nRow1);
470  *p++ = static_cast<sal_uInt16>(nTab1);
471  *p++ = static_cast<sal_uInt16>(nCol2);
472  *p++ = static_cast<sal_uInt16>(nRow2);
473  *p++ = static_cast<sal_uInt16>(nTab2);
474  sal_uInt16* pCount = p;
475  *p++ = 0;
476  sal_uInt16 nPos = 14;
477  SCTAB nTab = nTab1;
478  ScAddress aAdr;
479  while (nTab <= nTab2)
480  {
481  aAdr.SetTab( nTab );
482  SCROW nRow = nRow1;
483  while (nRow <= nRow2)
484  {
485  aAdr.SetRow( nRow );
486  SCCOL nCol = nCol1;
487  while (nCol <= nCol2)
488  {
489  aAdr.SetCol( nCol );
490  ScRefCellValue aCell(mrDoc, aAdr);
491  if (!aCell.isEmpty())
492  {
493  FormulaError nErr = FormulaError::NONE;
494  sal_uInt16 nType = 0; // 0 = number; 1 = string
495  double nVal = 0.0;
496  OUString aStr;
497  bool bOk = true;
498  switch (aCell.meType)
499  {
500  case CELLTYPE_STRING :
501  case CELLTYPE_EDIT :
502  aStr = aCell.getString(&mrDoc);
503  nType = 1;
504  break;
505  case CELLTYPE_VALUE :
506  nVal = GetValueCellValue(aAdr, aCell.mfValue);
507  break;
508  case CELLTYPE_FORMULA :
509  nErr = aCell.mpFormula->GetErrCode();
510  if (aCell.mpFormula->IsValue())
511  nVal = aCell.mpFormula->GetValue();
512  else
513  aStr = aCell.mpFormula->GetString().getString();
514  break;
515  default :
516  bOk = false;
517  break;
518  }
519  if (bOk)
520  {
521  if ((nPos + (5 * sizeof(sal_uInt16))) > MAXARRSIZE)
522  return false;
523  *p++ = static_cast<sal_uInt16>(nCol);
524  *p++ = static_cast<sal_uInt16>(nRow);
525  *p++ = static_cast<sal_uInt16>(nTab);
526  *p++ = static_cast<sal_uInt16>(nErr);
527  *p++ = nType;
528  nPos += 10;
529  if (nType == 0)
530  {
531  if ((nPos + sizeof(double)) > MAXARRSIZE)
532  return false;
533  memcpy( p, &nVal, sizeof(double));
534  nPos += sizeof(double);
535  }
536  else
537  {
538  OString aTmp(OUStringToOString(aStr,
539  osl_getThreadTextEncoding()));
540  // Old Add-Ins are limited to sal_uInt16 string
541  // lengths, and room for pad byte check.
542  if ( aTmp.getLength() > SAL_MAX_UINT16 - 2 )
543  return false;
544  // Append a 0-pad-byte if string length is odd
545  // MUST be sal_uInt16
546  sal_uInt16 nStrLen = static_cast<sal_uInt16>(aTmp.getLength());
547  sal_uInt16 nLen = ( nStrLen + 2 ) & ~1;
548  if ( (static_cast<sal_uLong>(nPos) + 2 + nLen) > MAXARRSIZE)
549  return false;
550  *p++ = nLen;
551  memcpy( p, aTmp.getStr(), nStrLen + 1);
552  nPos += 2 + nStrLen + 1;
553  sal_uInt8* q = pCellArr + nPos;
554  if( (nStrLen & 1) == 0 )
555  {
556  *q++ = 0;
557  nPos++;
558  }
559  }
560  nCount++;
561  p = reinterpret_cast<sal_uInt16*>( pCellArr + nPos );
562  }
563  }
564  nCol++;
565  }
566  nRow++;
567  }
568  nTab++;
569  }
570  *pCount = nCount;
571  return true;
572 }
573 
574 // Stack operations
575 
576 // Also releases a TempToken if appropriate.
577 
578 void ScInterpreter::PushWithoutError( const FormulaToken& r )
579 {
580  if ( sp >= MAXSTACK )
581  SetError( FormulaError::StackOverflow );
582  else
583  {
584  r.IncRef();
585  if( sp >= maxsp )
586  maxsp = sp + 1;
587  else
588  pStack[ sp ]->DecRef();
589  pStack[ sp ] = &r;
590  ++sp;
591  }
592 }
593 
594 void ScInterpreter::Push( const FormulaToken& r )
595 {
596  if ( sp >= MAXSTACK )
597  SetError( FormulaError::StackOverflow );
598  else
599  {
600  if (nGlobalError != FormulaError::NONE)
601  {
602  if (r.GetType() == svError)
603  PushWithoutError( r);
604  else
605  PushTempTokenWithoutError( new FormulaErrorToken( nGlobalError));
606  }
607  else
608  PushWithoutError( r);
609  }
610 }
611 
612 void ScInterpreter::PushTempToken( FormulaToken* p )
613 {
614  if ( sp >= MAXSTACK )
615  {
616  SetError( FormulaError::StackOverflow );
617  // p may be a dangling pointer hereafter!
618  p->DeleteIfZeroRef();
619  }
620  else
621  {
622  if (nGlobalError != FormulaError::NONE)
623  {
624  if (p->GetType() == svError)
625  {
626  p->SetError( nGlobalError);
627  PushTempTokenWithoutError( p);
628  }
629  else
630  {
631  // p may be a dangling pointer hereafter!
632  p->DeleteIfZeroRef();
633  PushTempTokenWithoutError( new FormulaErrorToken( nGlobalError));
634  }
635  }
636  else
637  PushTempTokenWithoutError( p);
638  }
639 }
640 
641 void ScInterpreter::PushTempTokenWithoutError( const FormulaToken* p )
642 {
643  p->IncRef();
644  if ( sp >= MAXSTACK )
645  {
646  SetError( FormulaError::StackOverflow );
647  // p may be a dangling pointer hereafter!
648  p->DecRef();
649  }
650  else
651  {
652  if( sp >= maxsp )
653  maxsp = sp + 1;
654  else
655  pStack[ sp ]->DecRef();
656  pStack[ sp ] = p;
657  ++sp;
658  }
659 }
660 
661 void ScInterpreter::PushTokenRef( const formula::FormulaConstTokenRef& x )
662 {
663  if ( sp >= MAXSTACK )
664  {
665  SetError( FormulaError::StackOverflow );
666  }
667  else
668  {
669  if (nGlobalError != FormulaError::NONE)
670  {
671  if (x->GetType() == svError && x->GetError() == nGlobalError)
672  PushTempTokenWithoutError( x.get());
673  else
674  PushTempTokenWithoutError( new FormulaErrorToken( nGlobalError));
675  }
676  else
677  PushTempTokenWithoutError( x.get());
678  }
679 }
680 
681 void ScInterpreter::PushCellResultToken( bool bDisplayEmptyAsString,
682  const ScAddress & rAddress, SvNumFormatType * pRetTypeExpr, sal_uInt32 * pRetIndexExpr, bool bFinalResult )
683 {
684  ScRefCellValue aCell(mrDoc, rAddress);
685  if (aCell.hasEmptyValue())
686  {
687  bool bInherited = (aCell.meType == CELLTYPE_FORMULA);
688  if (pRetTypeExpr && pRetIndexExpr)
689  mrDoc.GetNumberFormatInfo(mrContext, *pRetTypeExpr, *pRetIndexExpr, rAddress);
690  PushTempToken( new ScEmptyCellToken( bInherited, bDisplayEmptyAsString));
691  return;
692  }
693 
694  FormulaError nErr = FormulaError::NONE;
695  if (aCell.meType == CELLTYPE_FORMULA)
696  nErr = aCell.mpFormula->GetErrCode();
697 
698  if (nErr != FormulaError::NONE)
699  {
700  PushError( nErr);
701  if (pRetTypeExpr)
702  *pRetTypeExpr = SvNumFormatType::UNDEFINED;
703  if (pRetIndexExpr)
704  *pRetIndexExpr = 0;
705  }
706  else if (aCell.hasString())
707  {
708  svl::SharedString aRes;
709  GetCellString( aRes, aCell);
710  PushString( aRes);
711  if (pRetTypeExpr)
712  *pRetTypeExpr = SvNumFormatType::TEXT;
713  if (pRetIndexExpr)
714  *pRetIndexExpr = 0;
715  }
716  else
717  {
718  double fVal = GetCellValue(rAddress, aCell);
719  if (bFinalResult)
720  {
721  TreatDoubleError( fVal);
722  if (!IfErrorPushError())
723  PushTempTokenWithoutError( CreateFormulaDoubleToken( fVal));
724  }
725  else
726  {
727  PushDouble( fVal);
728  }
729  if (pRetTypeExpr)
730  *pRetTypeExpr = nCurFmtType;
731  if (pRetIndexExpr)
732  *pRetIndexExpr = nCurFmtIndex;
733  }
734 }
735 
736 // Simply throw away TOS.
737 
738 void ScInterpreter::Pop()
739 {
740  if( sp )
741  sp--;
742  else
743  SetError(FormulaError::UnknownStackVariable);
744 }
745 
746 // Simply throw away TOS and set error code, used with ocIsError et al.
747 
748 void ScInterpreter::PopError()
749 {
750  if( sp )
751  {
752  sp--;
753  if (pStack[sp]->GetType() == svError)
754  nGlobalError = pStack[sp]->GetError();
755  }
756  else
757  SetError(FormulaError::UnknownStackVariable);
758 }
759 
760 FormulaConstTokenRef ScInterpreter::PopToken()
761 {
762  if (sp)
763  {
764  sp--;
765  const FormulaToken* p = pStack[ sp ];
766  if (p->GetType() == svError)
767  nGlobalError = p->GetError();
768  return p;
769  }
770  else
771  SetError(FormulaError::UnknownStackVariable);
772  return nullptr;
773 }
774 
775 double ScInterpreter::PopDouble()
776 {
777  nCurFmtType = SvNumFormatType::NUMBER;
778  nCurFmtIndex = 0;
779  if( sp )
780  {
781  --sp;
782  const FormulaToken* p = pStack[ sp ];
783  switch (p->GetType())
784  {
785  case svError:
786  nGlobalError = p->GetError();
787  break;
788  case svDouble:
789  {
790  SvNumFormatType nType = static_cast<SvNumFormatType>(p->GetDoubleType());
791  if (nType != SvNumFormatType::ALL && nType != SvNumFormatType::UNDEFINED)
792  nCurFmtType = nType;
793  return p->GetDouble();
794  }
795  case svEmptyCell:
796  case svMissing:
797  return 0.0;
798  default:
799  SetError( FormulaError::IllegalArgument);
800  }
801  }
802  else
803  SetError( FormulaError::UnknownStackVariable);
804  return 0.0;
805 }
806 
807 svl::SharedString ScInterpreter::PopString()
808 {
809  nCurFmtType = SvNumFormatType::TEXT;
810  nCurFmtIndex = 0;
811  if( sp )
812  {
813  --sp;
814  const FormulaToken* p = pStack[ sp ];
815  switch (p->GetType())
816  {
817  case svError:
818  nGlobalError = p->GetError();
819  break;
820  case svString:
821  return p->GetString();
822  case svEmptyCell:
823  case svMissing:
824  return svl::SharedString::getEmptyString();
825  default:
826  SetError( FormulaError::IllegalArgument);
827  }
828  }
829  else
830  SetError( FormulaError::UnknownStackVariable);
831 
832  return svl::SharedString::getEmptyString();
833 }
834 
835 void ScInterpreter::ValidateRef( const ScSingleRefData & rRef )
836 {
837  SCCOL nCol;
838  SCROW nRow;
839  SCTAB nTab;
840  SingleRefToVars( rRef, nCol, nRow, nTab);
841 }
842 
843 void ScInterpreter::ValidateRef( const ScComplexRefData & rRef )
844 {
845  ValidateRef( rRef.Ref1);
846  ValidateRef( rRef.Ref2);
847 }
848 
849 void ScInterpreter::ValidateRef( const ScRefList & rRefList )
850 {
851  for (const auto& rRef : rRefList)
852  {
853  ValidateRef( rRef);
854  }
855 }
856 
857 void ScInterpreter::SingleRefToVars( const ScSingleRefData & rRef,
858  SCCOL & rCol, SCROW & rRow, SCTAB & rTab )
859 {
860  if ( rRef.IsColRel() )
861  rCol = aPos.Col() + rRef.Col();
862  else
863  rCol = rRef.Col();
864 
865  if ( rRef.IsRowRel() )
866  rRow = aPos.Row() + rRef.Row();
867  else
868  rRow = rRef.Row();
869 
870  if ( rRef.IsTabRel() )
871  rTab = aPos.Tab() + rRef.Tab();
872  else
873  rTab = rRef.Tab();
874 
875  if( !mrDoc.ValidCol( rCol) || rRef.IsColDeleted() )
876  {
877  SetError( FormulaError::NoRef );
878  rCol = 0;
879  }
880  if( !mrDoc.ValidRow( rRow) || rRef.IsRowDeleted() )
881  {
882  SetError( FormulaError::NoRef );
883  rRow = 0;
884  }
885  if( !ValidTab( rTab, mrDoc.GetTableCount() - 1) || rRef.IsTabDeleted() )
886  {
887  SetError( FormulaError::NoRef );
888  rTab = 0;
889  }
890 }
891 
892 void ScInterpreter::PopSingleRef(SCCOL& rCol, SCROW &rRow, SCTAB& rTab)
893 {
894  ScAddress aAddr(rCol, rRow, rTab);
895  PopSingleRef(aAddr);
896  rCol = aAddr.Col();
897  rRow = aAddr.Row();
898  rTab = aAddr.Tab();
899 }
900 
901 void ScInterpreter::PopSingleRef( ScAddress& rAdr )
902 {
903  if( sp )
904  {
905  --sp;
906  const FormulaToken* p = pStack[ sp ];
907  switch (p->GetType())
908  {
909  case svError:
910  nGlobalError = p->GetError();
911  break;
912  case svSingleRef:
913  {
914  const ScSingleRefData* pRefData = p->GetSingleRef();
915  if (pRefData->IsDeleted())
916  {
917  SetError( FormulaError::NoRef);
918  break;
919  }
920 
921  SCCOL nCol;
922  SCROW nRow;
923  SCTAB nTab;
924  SingleRefToVars( *pRefData, nCol, nRow, nTab);
925  rAdr.Set( nCol, nRow, nTab );
926  if (!mrDoc.m_TableOpList.empty())
927  ReplaceCell( rAdr );
928  }
929  break;
930  default:
931  SetError( FormulaError::IllegalParameter);
932  }
933  }
934  else
935  SetError( FormulaError::UnknownStackVariable);
936 }
937 
938 void ScInterpreter::DoubleRefToVars( const formula::FormulaToken* p,
939  SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1,
940  SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2 )
941 {
942  const ScComplexRefData& rCRef = *p->GetDoubleRef();
943  SingleRefToVars( rCRef.Ref1, rCol1, rRow1, rTab1);
944  SingleRefToVars( rCRef.Ref2, rCol2, rRow2, rTab2);
945  if (rCol2 < rCol1)
946  std::swap( rCol2, rCol1);
947  if (rRow2 < rRow1)
948  std::swap( rRow2, rRow1);
949  if (rTab2 < rTab1)
950  std::swap( rTab2, rTab1);
951  if (!mrDoc.m_TableOpList.empty())
952  {
953  ScRange aRange( rCol1, rRow1, rTab1, rCol2, rRow2, rTab2 );
954  if ( IsTableOpInRange( aRange ) )
955  SetError( FormulaError::IllegalParameter );
956  }
957 }
958 
959 ScDBRangeBase* ScInterpreter::PopDBDoubleRef()
960 {
961  StackVar eType = GetStackType();
962  switch (eType)
963  {
964  case svUnknown:
965  SetError(FormulaError::UnknownStackVariable);
966  break;
967  case svError:
968  PopError();
969  break;
970  case svDoubleRef:
971  {
972  SCCOL nCol1, nCol2;
973  SCROW nRow1, nRow2;
974  SCTAB nTab1, nTab2;
975  PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
976  if (nGlobalError != FormulaError::NONE)
977  break;
978  return new ScDBInternalRange(&mrDoc,
979  ScRange(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2));
980  }
981  case svMatrix:
982  case svExternalDoubleRef:
983  {
984  ScMatrixRef pMat;
985  if (eType == svMatrix)
986  pMat = PopMatrix();
987  else
988  PopExternalDoubleRef(pMat);
989  if (nGlobalError != FormulaError::NONE)
990  break;
991  return new ScDBExternalRange(&mrDoc, pMat);
992  }
993  default:
994  SetError( FormulaError::IllegalParameter);
995  }
996 
997  return nullptr;
998 }
999 
1000 void ScInterpreter::PopDoubleRef(SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1,
1001  SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2)
1002 {
1003  if( sp )
1004  {
1005  --sp;
1006  const FormulaToken* p = pStack[ sp ];
1007  switch (p->GetType())
1008  {
1009  case svError:
1010  nGlobalError = p->GetError();
1011  break;
1012  case svDoubleRef:
1013  DoubleRefToVars( p, rCol1, rRow1, rTab1, rCol2, rRow2, rTab2);
1014  break;
1015  default:
1016  SetError( FormulaError::IllegalParameter);
1017  }
1018  }
1019  else
1020  SetError( FormulaError::UnknownStackVariable);
1021 }
1022 
1023 void ScInterpreter::DoubleRefToRange( const ScComplexRefData & rCRef,
1024  ScRange & rRange, bool bDontCheckForTableOp )
1025 {
1026  SCCOL nCol;
1027  SCROW nRow;
1028  SCTAB nTab;
1029  SingleRefToVars( rCRef.Ref1, nCol, nRow, nTab);
1030  rRange.aStart.Set( nCol, nRow, nTab );
1031  SingleRefToVars( rCRef.Ref2, nCol, nRow, nTab);
1032  rRange.aEnd.Set( nCol, nRow, nTab );
1033  rRange.PutInOrder();
1034  if (!mrDoc.m_TableOpList.empty() && !bDontCheckForTableOp)
1035  {
1036  if ( IsTableOpInRange( rRange ) )
1037  SetError( FormulaError::IllegalParameter );
1038  }
1039 }
1040 
1041 void ScInterpreter::PopDoubleRef( ScRange & rRange, short & rParam, size_t & rRefInList )
1042 {
1043  if (sp)
1044  {
1045  const formula::FormulaToken* pToken = pStack[ sp-1 ];
1046  switch (pToken->GetType())
1047  {
1048  case svError:
1049  nGlobalError = pToken->GetError();
1050  break;
1051  case svDoubleRef:
1052  {
1053  --sp;
1054  const ScComplexRefData* pRefData = pToken->GetDoubleRef();
1055  if (pRefData->IsDeleted())
1056  {
1057  SetError( FormulaError::NoRef);
1058  break;
1059  }
1060  DoubleRefToRange( *pRefData, rRange);
1061  break;
1062  }
1063  case svRefList:
1064  {
1065  const ScRefList* pList = pToken->GetRefList();
1066  if (rRefInList < pList->size())
1067  {
1068  DoubleRefToRange( (*pList)[rRefInList], rRange);
1069  if (++rRefInList < pList->size())
1070  ++rParam;
1071  else
1072  {
1073  --sp;
1074  rRefInList = 0;
1075  }
1076  }
1077  else
1078  {
1079  --sp;
1080  rRefInList = 0;
1081  SetError( FormulaError::IllegalParameter);
1082  }
1083  }
1084  break;
1085  default:
1086  SetError( FormulaError::IllegalParameter);
1087  }
1088  }
1089  else
1090  SetError( FormulaError::UnknownStackVariable);
1091 }
1092 
1093 void ScInterpreter::PopDoubleRef( ScRange& rRange, bool bDontCheckForTableOp )
1094 {
1095  if( sp )
1096  {
1097  --sp;
1098  const FormulaToken* p = pStack[ sp ];
1099  switch (p->GetType())
1100  {
1101  case svError:
1102  nGlobalError = p->GetError();
1103  break;
1104  case svDoubleRef:
1105  DoubleRefToRange( *p->GetDoubleRef(), rRange, bDontCheckForTableOp);
1106  break;
1107  default:
1108  SetError( FormulaError::IllegalParameter);
1109  }
1110  }
1111  else
1112  SetError( FormulaError::UnknownStackVariable);
1113 }
1114 
1115 void ScInterpreter::PopExternalSingleRef(sal_uInt16& rFileId, OUString& rTabName, ScSingleRefData& rRef)
1116 {
1117  if (!sp)
1118  {
1119  SetError(FormulaError::UnknownStackVariable);
1120  return;
1121  }
1122 
1123  --sp;
1124  const FormulaToken* p = pStack[sp];
1125  StackVar eType = p->GetType();
1126 
1127  if (eType == svError)
1128  {
1129  nGlobalError = p->GetError();
1130  return;
1131  }
1132 
1133  if (eType != svExternalSingleRef)
1134  {
1135  SetError( FormulaError::IllegalParameter);
1136  return;
1137  }
1138 
1139  rFileId = p->GetIndex();
1140  rTabName = p->GetString().getString();
1141  rRef = *p->GetSingleRef();
1142 }
1143 
1144 void ScInterpreter::PopExternalSingleRef(ScExternalRefCache::TokenRef& rToken, ScExternalRefCache::CellFormat* pFmt)
1145 {
1146  sal_uInt16 nFileId;
1147  OUString aTabName;
1148  ScSingleRefData aData;
1149  PopExternalSingleRef(nFileId, aTabName, aData, rToken, pFmt);
1150 }
1151 
1152 void ScInterpreter::PopExternalSingleRef(
1153  sal_uInt16& rFileId, OUString& rTabName, ScSingleRefData& rRef,
1154  ScExternalRefCache::TokenRef& rToken, ScExternalRefCache::CellFormat* pFmt)
1155 {
1156  PopExternalSingleRef(rFileId, rTabName, rRef);
1157  if (nGlobalError != FormulaError::NONE)
1158  return;
1159 
1160  ScExternalRefManager* pRefMgr = mrDoc.GetExternalRefManager();
1161  const OUString* pFile = pRefMgr->getExternalFileName(rFileId);
1162  if (!pFile)
1163  {
1164  SetError(FormulaError::NoName);
1165  return;
1166  }
1167 
1168  if (rRef.IsTabRel())
1169  {
1170  OSL_FAIL("ScCompiler::GetToken: external single reference must have an absolute table reference!");
1171  SetError(FormulaError::NoRef);
1172  return;
1173  }
1174 
1175  ScAddress aAddr = rRef.toAbs(mrDoc, aPos);
1176  ScExternalRefCache::CellFormat aFmt;
1177  ScExternalRefCache::TokenRef xNew = pRefMgr->getSingleRefToken(
1178  rFileId, rTabName, aAddr, &aPos, nullptr, &aFmt);
1179 
1180  if (!xNew)
1181  {
1182  SetError(FormulaError::NoRef);
1183  return;
1184  }
1185 
1186  if (xNew->GetType() == svError)
1187  SetError( xNew->GetError());
1188 
1189  rToken = xNew;
1190  if (pFmt)
1191  *pFmt = aFmt;
1192 }
1193 
1194 void ScInterpreter::PopExternalDoubleRef(sal_uInt16& rFileId, OUString& rTabName, ScComplexRefData& rRef)
1195 {
1196  if (!sp)
1197  {
1198  SetError(FormulaError::UnknownStackVariable);
1199  return;
1200  }
1201 
1202  --sp;
1203  const FormulaToken* p = pStack[sp];
1204  StackVar eType = p->GetType();
1205 
1206  if (eType == svError)
1207  {
1208  nGlobalError = p->GetError();
1209  return;
1210  }
1211 
1212  if (eType != svExternalDoubleRef)
1213  {
1214  SetError( FormulaError::IllegalParameter);
1215  return;
1216  }
1217 
1218  rFileId = p->GetIndex();
1219  rTabName = p->GetString().getString();
1220  rRef = *p->GetDoubleRef();
1221 }
1222 
1223 void ScInterpreter::PopExternalDoubleRef(ScExternalRefCache::TokenArrayRef& rArray)
1224 {
1225  sal_uInt16 nFileId;
1226  OUString aTabName;
1227  ScComplexRefData aData;
1228  PopExternalDoubleRef(nFileId, aTabName, aData);
1229  if (nGlobalError != FormulaError::NONE)
1230  return;
1231 
1232  GetExternalDoubleRef(nFileId, aTabName, aData, rArray);
1233  if (nGlobalError != FormulaError::NONE)
1234  return;
1235 }
1236 
1237 void ScInterpreter::PopExternalDoubleRef(ScMatrixRef& rMat)
1238 {
1239  ScExternalRefCache::TokenArrayRef pArray;
1240  PopExternalDoubleRef(pArray);
1241  if (nGlobalError != FormulaError::NONE)
1242  return;
1243 
1244  // For now, we only support single range data for external
1245  // references, which means the array should only contain a
1246  // single matrix token.
1247  formula::FormulaToken* p = pArray->FirstToken();
1248  if (!p || p->GetType() != svMatrix)
1249  SetError( FormulaError::IllegalParameter);
1250  else
1251  {
1252  rMat = p->GetMatrix();
1253  if (!rMat)
1254  SetError( FormulaError::UnknownVariable);
1255  }
1256 }
1257 
1258 void ScInterpreter::GetExternalDoubleRef(
1259  sal_uInt16 nFileId, const OUString& rTabName, const ScComplexRefData& rData, ScExternalRefCache::TokenArrayRef& rArray)
1260 {
1261  ScExternalRefManager* pRefMgr = mrDoc.GetExternalRefManager();
1262  const OUString* pFile = pRefMgr->getExternalFileName(nFileId);
1263  if (!pFile)
1264  {
1265  SetError(FormulaError::NoName);
1266  return;
1267  }
1268  if (rData.Ref1.IsTabRel() || rData.Ref2.IsTabRel())
1269  {
1270  OSL_FAIL("ScCompiler::GetToken: external double reference must have an absolute table reference!");
1271  SetError(FormulaError::NoRef);
1272  return;
1273  }
1274 
1275  ScComplexRefData aData(rData);
1276  ScRange aRange = aData.toAbs(mrDoc, aPos);
1277  if (!mrDoc.ValidColRow(aRange.aStart.Col(), aRange.aStart.Row()) || !mrDoc.ValidColRow(aRange.aEnd.Col(), aRange.aEnd.Row()))
1278  {
1279  SetError(FormulaError::NoRef);
1280  return;
1281  }
1282 
1283  ScExternalRefCache::TokenArrayRef pArray = pRefMgr->getDoubleRefTokens(
1284  nFileId, rTabName, aRange, &aPos);
1285 
1286  if (!pArray)
1287  {
1288  SetError(FormulaError::IllegalArgument);
1289  return;
1290  }
1291 
1292  formula::FormulaTokenArrayPlainIterator aIter(*pArray);
1293  formula::FormulaToken* pToken = aIter.First();
1294  assert(pToken);
1295  if (pToken->GetType() == svError)
1296  {
1297  SetError( pToken->GetError());
1298  return;
1299  }
1300  if (pToken->GetType() != svMatrix)
1301  {
1302  SetError(FormulaError::IllegalArgument);
1303  return;
1304  }
1305 
1306  if (aIter.Next())
1307  {
1308  // Can't handle more than one matrix per parameter.
1309  SetError( FormulaError::IllegalArgument);
1310  return;
1311  }
1312 
1313  rArray = pArray;
1314 }
1315 
1316 bool ScInterpreter::PopDoubleRefOrSingleRef( ScAddress& rAdr )
1317 {
1318  switch ( GetStackType() )
1319  {
1320  case svDoubleRef :
1321  {
1322  ScRange aRange;
1323  PopDoubleRef( aRange, true );
1324  return DoubleRefToPosSingleRef( aRange, rAdr );
1325  }
1326  case svSingleRef :
1327  {
1328  PopSingleRef( rAdr );
1329  return true;
1330  }
1331  default:
1332  PopError();
1333  SetError( FormulaError::NoRef );
1334  }
1335  return false;
1336 }
1337 
1338 void ScInterpreter::PopDoubleRefPushMatrix()
1339 {
1340  if ( GetStackType() == svDoubleRef )
1341  {
1342  ScMatrixRef pMat = GetMatrix();
1343  if ( pMat )
1344  PushMatrix( pMat );
1345  else
1346  PushIllegalParameter();
1347  }
1348  else
1349  SetError( FormulaError::NoRef );
1350 }
1351 
1352 void ScInterpreter::PopRefListPushMatrixOrRef()
1353 {
1354  if ( GetStackType() == svRefList )
1355  {
1356  FormulaConstTokenRef xTok = pStack[sp-1];
1357  const std::vector<ScComplexRefData>* pv = xTok->GetRefList();
1358  if (pv)
1359  {
1360  const size_t nEntries = pv->size();
1361  if (nEntries == 1)
1362  {
1363  --sp;
1364  PushTempTokenWithoutError( new ScDoubleRefToken( mrDoc.GetSheetLimits(), (*pv)[0] ));
1365  }
1366  else if (bMatrixFormula)
1367  {
1368  // Only single cells can be stuffed into a column vector.
1369  // XXX NOTE: Excel doesn't do this but returns #VALUE! instead.
1370  // Though there's no compelling reason not to...
1371  for (const auto & rRef : *pv)
1372  {
1373  if (rRef.Ref1 != rRef.Ref2)
1374  return;
1375  }
1376  ScMatrixRef xMat = GetNewMat( 1, nEntries, true); // init empty
1377  if (!xMat)
1378  return;
1379  for (size_t i=0; i < nEntries; ++i)
1380  {
1381  SCCOL nCol; SCROW nRow; SCTAB nTab;
1382  SingleRefToVars( (*pv)[i].Ref1, nCol, nRow, nTab);
1383  if (nGlobalError == FormulaError::NONE)
1384  {
1385  ScAddress aAdr( nCol, nRow, nTab);
1386  ScRefCellValue aCell(mrDoc, aAdr);
1387  if (aCell.hasError())
1388  xMat->PutError( aCell.mpFormula->GetErrCode(), 0, i);
1389  else if (aCell.hasEmptyValue())
1390  xMat->PutEmpty( 0, i);
1391  else if (aCell.hasString())
1392  xMat->PutString( mrStrPool.intern( aCell.getString(&mrDoc)), 0, i);
1393  else
1394  xMat->PutDouble( aCell.getValue(), 0, i);
1395  }
1396  else
1397  {
1398  xMat->PutError( nGlobalError, 0, i);
1399  nGlobalError = FormulaError::NONE;
1400  }
1401  }
1402  --sp;
1403  PushMatrix( xMat);
1404  }
1405  }
1406  // else: keep token on stack, something will handle the error
1407  }
1408  else
1409  SetError( FormulaError::NoRef );
1410 }
1411 
1412 void ScInterpreter::ConvertMatrixJumpConditionToMatrix()
1413 {
1414  StackVar eStackType = GetStackType();
1415  if (eStackType == svUnknown)
1416  return; // can't do anything, some caller will catch that
1417  if (eStackType == svMatrix)
1418  return; // already matrix, nothing to do
1419 
1420  if (eStackType != svDoubleRef && GetStackType(2) != svJumpMatrix)
1421  return; // always convert svDoubleRef, others only in JumpMatrix context
1422 
1423  GetTokenMatrixMap(); // make sure it exists, create if not.
1424  ScMatrixRef pMat = GetMatrix();
1425  if ( pMat )
1426  PushMatrix( pMat );
1427  else
1428  PushIllegalParameter();
1429 }
1430 
1431 std::unique_ptr<ScTokenMatrixMap> ScInterpreter::CreateTokenMatrixMap()
1432 {
1433  return std::make_unique<ScTokenMatrixMap>();
1434 }
1435 
1436 bool ScInterpreter::ConvertMatrixParameters()
1437 {
1438  sal_uInt16 nParams = pCur->GetParamCount();
1439  OSL_ENSURE( nParams <= sp, "ConvertMatrixParameters: stack/param count mismatch");
1440  SCSIZE nJumpCols = 0, nJumpRows = 0;
1441  for ( sal_uInt16 i=1; i <= nParams && i <= sp; ++i )
1442  {
1443  const FormulaToken* p = pStack[ sp - i ];
1444  if ( p->GetOpCode() != ocPush && p->GetOpCode() != ocMissing)
1445  {
1446  OSL_FAIL( "ConvertMatrixParameters: not a push");
1447  }
1448  else
1449  {
1450  switch ( p->GetType() )
1451  {
1452  case svDouble:
1453  case svString:
1454  case svSingleRef:
1455  case svExternalSingleRef:
1456  case svMissing:
1457  case svError:
1458  case svEmptyCell:
1459  // nothing to do
1460  break;
1461  case svMatrix:
1462  {
1463  if ( ScParameterClassification::GetParameterType( pCur, nParams - i)
1464  == formula::ParamClass::Value )
1465  { // only if single value expected
1466  ScConstMatrixRef pMat = p->GetMatrix();
1467  if ( !pMat )
1468  SetError( FormulaError::UnknownVariable);
1469  else
1470  {
1471  SCSIZE nCols, nRows;
1472  pMat->GetDimensions( nCols, nRows);
1473  if ( nJumpCols < nCols )
1474  nJumpCols = nCols;
1475  if ( nJumpRows < nRows )
1476  nJumpRows = nRows;
1477  }
1478  }
1479  }
1480  break;
1481  case svDoubleRef:
1482  {
1483  formula::ParamClass eType = ScParameterClassification::GetParameterType( pCur, nParams - i);
1484  if ( eType != formula::ParamClass::Reference &&
1485  eType != formula::ParamClass::ReferenceOrRefArray &&
1486  eType != formula::ParamClass::ReferenceOrForceArray &&
1487  // For scalar Value: convert to Array/JumpMatrix
1488  // only if in array formula context, else (function
1489  // has ForceArray or ReferenceOrForceArray
1490  // parameter *somewhere else*) pick a normal
1491  // position dependent implicit intersection later.
1492  (eType != formula::ParamClass::Value || IsInArrayContext()))
1493  {
1494  SCCOL nCol1, nCol2;
1495  SCROW nRow1, nRow2;
1496  SCTAB nTab1, nTab2;
1497  DoubleRefToVars( p, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
1498  // Make sure the map exists, created if not.
1499  GetTokenMatrixMap();
1500  ScMatrixRef pMat = CreateMatrixFromDoubleRef( p,
1501  nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
1502  if (pMat)
1503  {
1504  if ( eType == formula::ParamClass::Value )
1505  { // only if single value expected
1506  if ( nJumpCols < o3tl::make_unsigned(nCol2 - nCol1 + 1) )
1507  nJumpCols = static_cast<SCSIZE>(nCol2 - nCol1 + 1);
1508  if ( nJumpRows < o3tl::make_unsigned(nRow2 - nRow1 + 1) )
1509  nJumpRows = static_cast<SCSIZE>(nRow2 - nRow1 + 1);
1510  }
1511  formula::FormulaToken* pNew = new ScMatrixToken( pMat);
1512  pNew->IncRef();
1513  pStack[ sp - i ] = pNew;
1514  p->DecRef(); // p may be dead now!
1515  }
1516  }
1517  }
1518  break;
1519  case svExternalDoubleRef:
1520  {
1521  formula::ParamClass eType = ScParameterClassification::GetParameterType( pCur, nParams - i);
1522  if (eType == formula::ParamClass::Value || eType == formula::ParamClass::Array)
1523  {
1524  sal_uInt16 nFileId = p->GetIndex();
1525  OUString aTabName = p->GetString().getString();
1526  const ScComplexRefData& rRef = *p->GetDoubleRef();
1527  ScExternalRefCache::TokenArrayRef pArray;
1528  GetExternalDoubleRef(nFileId, aTabName, rRef, pArray);
1529  if (nGlobalError != FormulaError::NONE || !pArray)
1530  break;
1531  formula::FormulaToken* pTemp = pArray->FirstToken();
1532  if (!pTemp)
1533  break;
1534 
1535  ScMatrixRef pMat = pTemp->GetMatrix();
1536  if (pMat)
1537  {
1538  if (eType == formula::ParamClass::Value)
1539  { // only if single value expected
1540  SCSIZE nC, nR;
1541  pMat->GetDimensions( nC, nR);
1542  if (nJumpCols < nC)
1543  nJumpCols = nC;
1544  if (nJumpRows < nR)
1545  nJumpRows = nR;
1546  }
1547  formula::FormulaToken* pNew = new ScMatrixToken( pMat);
1548  pNew->IncRef();
1549  pStack[ sp - i ] = pNew;
1550  p->DecRef(); // p may be dead now!
1551  }
1552  }
1553  }
1554  break;
1555  case svRefList:
1556  {
1557  formula::ParamClass eType = ScParameterClassification::GetParameterType( pCur, nParams - i);
1558  if ( eType != formula::ParamClass::Reference &&
1559  eType != formula::ParamClass::ReferenceOrRefArray &&
1560  eType != formula::ParamClass::ReferenceOrForceArray &&
1561  eType != formula::ParamClass::ForceArray)
1562  {
1563  // can't convert to matrix
1564  SetError( FormulaError::NoValue);
1565  }
1566  // else: the consuming function has to decide if and how to
1567  // handle a reference list argument in array context.
1568  }
1569  break;
1570  default:
1571  OSL_FAIL( "ConvertMatrixParameters: unknown parameter type");
1572  }
1573  }
1574  }
1575  if( nJumpCols && nJumpRows )
1576  {
1577  short nPC = aCode.GetPC();
1578  short nStart = nPC - 1; // restart on current code (-1)
1579  short nNext = nPC; // next instruction after subroutine
1580  short nStop = nPC + 1; // stop subroutine before reaching that
1581  FormulaConstTokenRef xNew;
1582  ScTokenMatrixMap::const_iterator aMapIter;
1583  if (pTokenMatrixMap && ((aMapIter = pTokenMatrixMap->find( pCur)) != pTokenMatrixMap->end()))
1584  xNew = (*aMapIter).second;
1585  else
1586  {
1587  auto pJumpMat = std::make_shared<ScJumpMatrix>( pCur->GetOpCode(), nJumpCols, nJumpRows);
1588  pJumpMat->SetAllJumps( 1.0, nStart, nNext, nStop);
1589  // pop parameters and store in ScJumpMatrix, push in JumpMatrix()
1590  ScTokenVec aParams(nParams);
1591  for ( sal_uInt16 i=1; i <= nParams && sp > 0; ++i )
1592  {
1593  const FormulaToken* p = pStack[ --sp ];
1594  p->IncRef();
1595  // store in reverse order such that a push may simply iterate
1596  aParams[ nParams - i ] = p;
1597  }
1598  pJumpMat->SetJumpParameters( std::move(aParams) );
1599  xNew = new ScJumpMatrixToken( std::move(pJumpMat) );
1600  GetTokenMatrixMap().emplace(pCur, xNew);
1601  }
1602  PushTempTokenWithoutError( xNew.get());
1603  // set continuation point of path for main code line
1604  aCode.Jump( nNext, nNext);
1605  return true;
1606  }
1607  return false;
1608 }
1609 
1610 ScMatrixRef ScInterpreter::PopMatrix()
1611 {
1612  if( sp )
1613  {
1614  --sp;
1615  const FormulaToken* p = pStack[ sp ];
1616  switch (p->GetType())
1617  {
1618  case svError:
1619  nGlobalError = p->GetError();
1620  break;
1621  case svMatrix:
1622  {
1623  // ScMatrix itself maintains an im/mutable flag that should
1624  // be obeyed where necessary... so we can return ScMatrixRef
1625  // here instead of ScConstMatrixRef.
1626  ScMatrix* pMat = const_cast<FormulaToken*>(p)->GetMatrix();
1627  if ( pMat )
1628  pMat->SetErrorInterpreter( this);
1629  else
1630  SetError( FormulaError::UnknownVariable);
1631  return pMat;
1632  }
1633  default:
1634  SetError( FormulaError::IllegalParameter);
1635  }
1636  }
1637  else
1638  SetError( FormulaError::UnknownStackVariable);
1639  return nullptr;
1640 }
1641 
1642 sc::RangeMatrix ScInterpreter::PopRangeMatrix()
1643 {
1644  sc::RangeMatrix aRet;
1645  if (sp)
1646  {
1647  switch (pStack[sp-1]->GetType())
1648  {
1649  case svMatrix:
1650  {
1651  --sp;
1652  const FormulaToken* p = pStack[sp];
1653  aRet.mpMat = const_cast<FormulaToken*>(p)->GetMatrix();
1654  if (aRet.mpMat)
1655  {
1656  aRet.mpMat->SetErrorInterpreter(this);
1657  if (p->GetByte() == MATRIX_TOKEN_HAS_RANGE)
1658  {
1659  const ScComplexRefData& rRef = *p->GetDoubleRef();
1660  if (!rRef.Ref1.IsColRel() && !rRef.Ref1.IsRowRel() && !rRef.Ref2.IsColRel() && !rRef.Ref2.IsRowRel())
1661  {
1662  aRet.mnCol1 = rRef.Ref1.Col();
1663  aRet.mnRow1 = rRef.Ref1.Row();
1664  aRet.mnTab1 = rRef.Ref1.Tab();
1665  aRet.mnCol2 = rRef.Ref2.Col();
1666  aRet.mnRow2 = rRef.Ref2.Row();
1667  aRet.mnTab2 = rRef.Ref2.Tab();
1668  }
1669  }
1670  }
1671  else
1672  SetError( FormulaError::UnknownVariable);
1673  }
1674  break;
1675  default:
1676  aRet.mpMat = PopMatrix();
1677  }
1678  }
1679  return aRet;
1680 }
1681 
1682 void ScInterpreter::QueryMatrixType(const ScMatrixRef& xMat, SvNumFormatType& rRetTypeExpr, sal_uInt32& rRetIndexExpr)
1683 {
1684  if (xMat)
1685  {
1686  SCSIZE nCols, nRows;
1687  xMat->GetDimensions(nCols, nRows);
1688  ScMatrixValue nMatVal = xMat->Get(0, 0);
1689  ScMatValType nMatValType = nMatVal.nType;
1690  if (ScMatrix::IsNonValueType( nMatValType))
1691  {
1692  if ( xMat->IsEmptyPath( 0, 0))
1693  { // result of empty FALSE jump path
1694  FormulaTokenRef xRes = CreateFormulaDoubleToken( 0.0);
1695  PushTempToken( new ScMatrixFormulaCellToken(nCols, nRows, xMat, xRes.get()));
1696  rRetTypeExpr = SvNumFormatType::LOGICAL;
1697  }
1698  else if ( xMat->IsEmptyResult( 0, 0))
1699  { // empty formula result
1700  FormulaTokenRef xRes = new ScEmptyCellToken( true, true); // inherited, display empty
1701  PushTempToken( new ScMatrixFormulaCellToken(nCols, nRows, xMat, xRes.get()));
1702  }
1703  else if ( xMat->IsEmpty( 0, 0))
1704  { // empty or empty cell
1705  FormulaTokenRef xRes = new ScEmptyCellToken( false, true); // not inherited, display empty
1706  PushTempToken( new ScMatrixFormulaCellToken(nCols, nRows, xMat, xRes.get()));
1707  }
1708  else
1709  {
1710  FormulaTokenRef xRes = new FormulaStringToken( nMatVal.GetString() );
1711  PushTempToken( new ScMatrixFormulaCellToken(nCols, nRows, xMat, xRes.get()));
1712  rRetTypeExpr = SvNumFormatType::TEXT;
1713  }
1714  }
1715  else
1716  {
1717  FormulaError nErr = GetDoubleErrorValue( nMatVal.fVal);
1718  FormulaTokenRef xRes;
1719  if (nErr != FormulaError::NONE)
1720  xRes = new FormulaErrorToken( nErr);
1721  else
1722  xRes = CreateFormulaDoubleToken( nMatVal.fVal);
1723  PushTempToken( new ScMatrixFormulaCellToken(nCols, nRows, xMat, xRes.get()));
1724  if ( rRetTypeExpr != SvNumFormatType::LOGICAL )
1725  rRetTypeExpr = SvNumFormatType::NUMBER;
1726  }
1727  rRetIndexExpr = 0;
1728  xMat->SetErrorInterpreter( nullptr);
1729  }
1730  else
1731  SetError( FormulaError::UnknownStackVariable);
1732 }
1733 
1734 formula::FormulaToken* ScInterpreter::CreateFormulaDoubleToken( double fVal, SvNumFormatType nFmt )
1735 {
1736  assert( mrContext.maTokens.size() == TOKEN_CACHE_SIZE );
1737 
1738  // Find a spare token
1739  for ( auto p : mrContext.maTokens )
1740  {
1741  if (p && p->GetRef() == 1)
1742  {
1743  p->GetDoubleAsReference() = fVal;
1744  p->SetDoubleType( static_cast<sal_Int16>(nFmt) );
1745  return p;
1746  }
1747  }
1748 
1749  // Allocate a new token
1750  auto p = new FormulaTypedDoubleToken( fVal, static_cast<sal_Int16>(nFmt) );
1751  if ( mrContext.maTokens[mrContext.mnTokenCachePos] )
1752  mrContext.maTokens[mrContext.mnTokenCachePos]->DecRef();
1753  mrContext.maTokens[mrContext.mnTokenCachePos] = p;
1754  p->IncRef();
1755  mrContext.mnTokenCachePos = (mrContext.mnTokenCachePos + 1) % TOKEN_CACHE_SIZE;
1756  return p;
1757 }
1758 
1759 formula::FormulaToken* ScInterpreter::CreateDoubleOrTypedToken( double fVal )
1760 {
1761  // NumberFormat::NUMBER is the default untyped double.
1762  if (nFuncFmtType != SvNumFormatType::ALL && nFuncFmtType != SvNumFormatType::NUMBER &&
1763  nFuncFmtType != SvNumFormatType::UNDEFINED)
1764  return CreateFormulaDoubleToken( fVal, nFuncFmtType);
1765  else
1766  return CreateFormulaDoubleToken( fVal);
1767 }
1768 
1769 void ScInterpreter::PushDouble(double nVal)
1770 {
1771  TreatDoubleError( nVal );
1772  if (!IfErrorPushError())
1773  PushTempTokenWithoutError( CreateDoubleOrTypedToken( nVal));
1774 }
1775 
1776 void ScInterpreter::PushInt(int nVal)
1777 {
1778  if (!IfErrorPushError())
1779  PushTempTokenWithoutError( CreateDoubleOrTypedToken( nVal));
1780 }
1781 
1782 void ScInterpreter::PushStringBuffer( const sal_Unicode* pString )
1783 {
1784  if ( pString )
1785  {
1786  svl::SharedString aSS = mrDoc.GetSharedStringPool().intern(OUString(pString));
1787  PushString(aSS);
1788  }
1789  else
1790  PushString(svl::SharedString::getEmptyString());
1791 }
1792 
1793 void ScInterpreter::PushString( const OUString& rStr )
1794 {
1795  PushString(mrDoc.GetSharedStringPool().intern(rStr));
1796 }
1797 
1798 void ScInterpreter::PushString( const svl::SharedString& rString )
1799 {
1800  if (!IfErrorPushError())
1801  PushTempTokenWithoutError( new FormulaStringToken( rString ) );
1802 }
1803 
1804 void ScInterpreter::PushSingleRef(SCCOL nCol, SCROW nRow, SCTAB nTab)
1805 {
1806  if (!IfErrorPushError())
1807  {
1808  ScSingleRefData aRef;
1809  aRef.InitAddress(ScAddress(nCol,nRow,nTab));
1810  PushTempTokenWithoutError( new ScSingleRefToken( mrDoc.GetSheetLimits(), aRef ) );
1811  }
1812 }
1813 
1814 void ScInterpreter::PushDoubleRef(SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
1815  SCCOL nCol2, SCROW nRow2, SCTAB nTab2)
1816 {
1817  if (!IfErrorPushError())
1818  {
1819  ScComplexRefData aRef;
1820  aRef.InitRange(ScRange(nCol1,nRow1,nTab1,nCol2,nRow2,nTab2));
1821  PushTempTokenWithoutError( new ScDoubleRefToken( mrDoc.GetSheetLimits(), aRef ) );
1822  }
1823 }
1824 
1825 void ScInterpreter::PushExternalSingleRef(
1826  sal_uInt16 nFileId, const OUString& rTabName, SCCOL nCol, SCROW nRow, SCTAB nTab)
1827 {
1828  if (!IfErrorPushError())
1829  {
1830  ScSingleRefData aRef;
1831  aRef.InitAddress(ScAddress(nCol,nRow,nTab));
1832  PushTempTokenWithoutError( new ScExternalSingleRefToken(nFileId,
1833  mrDoc.GetSharedStringPool().intern( rTabName), aRef)) ;
1834  }
1835 }
1836 
1837 void ScInterpreter::PushExternalDoubleRef(
1838  sal_uInt16 nFileId, const OUString& rTabName,
1839  SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2)
1840 {
1841  if (!IfErrorPushError())
1842  {
1843  ScComplexRefData aRef;
1844  aRef.InitRange(ScRange(nCol1,nRow1,nTab1,nCol2,nRow2,nTab2));
1845  PushTempTokenWithoutError( new ScExternalDoubleRefToken(nFileId,
1846  mrDoc.GetSharedStringPool().intern( rTabName), aRef) );
1847  }
1848 }
1849 
1850 void ScInterpreter::PushSingleRef( const ScRefAddress& rRef )
1851 {
1852  if (!IfErrorPushError())
1853  {
1854  ScSingleRefData aRef;
1855  aRef.InitFromRefAddress( mrDoc, rRef, aPos);
1856  PushTempTokenWithoutError( new ScSingleRefToken( mrDoc.GetSheetLimits(), aRef ) );
1857  }
1858 }
1859 
1860 void ScInterpreter::PushDoubleRef( const ScRefAddress& rRef1, const ScRefAddress& rRef2 )
1861 {
1862  if (!IfErrorPushError())
1863  {
1864  ScComplexRefData aRef;
1865  aRef.InitFromRefAddresses( mrDoc, rRef1, rRef2, aPos);
1866  PushTempTokenWithoutError( new ScDoubleRefToken( mrDoc.GetSheetLimits(), aRef ) );
1867  }
1868 }
1869 
1870 void ScInterpreter::PushMatrix( const sc::RangeMatrix& rMat )
1871 {
1872  if (!rMat.isRangeValid())
1873  {
1874  // Just push the matrix part only.
1875  PushMatrix(rMat.mpMat);
1876  return;
1877  }
1878 
1879  rMat.mpMat->SetErrorInterpreter(nullptr);
1880  nGlobalError = FormulaError::NONE;
1881  PushTempTokenWithoutError(new ScMatrixRangeToken(rMat));
1882 }
1883 
1884 void ScInterpreter::PushMatrix(const ScMatrixRef& pMat)
1885 {
1886  pMat->SetErrorInterpreter( nullptr);
1887  // No if (!IfErrorPushError()) because ScMatrix stores errors itself,
1888  // but with notifying ScInterpreter via nGlobalError, substituting it would
1889  // mean to inherit the error on all array elements in all following
1890  // operations.
1891  nGlobalError = FormulaError::NONE;
1892  PushTempTokenWithoutError( new ScMatrixToken( pMat ) );
1893 }
1894 
1895 void ScInterpreter::PushError( FormulaError nError )
1896 {
1897  SetError( nError ); // only sets error if not already set
1898  PushTempTokenWithoutError( new FormulaErrorToken( nGlobalError));
1899 }
1900 
1901 void ScInterpreter::PushParameterExpected()
1902 {
1903  PushError( FormulaError::ParameterExpected);
1904 }
1905 
1906 void ScInterpreter::PushIllegalParameter()
1907 {
1908  PushError( FormulaError::IllegalParameter);
1909 }
1910 
1911 void ScInterpreter::PushIllegalArgument()
1912 {
1913  PushError( FormulaError::IllegalArgument);
1914 }
1915 
1916 void ScInterpreter::PushNA()
1917 {
1918  PushError( FormulaError::NotAvailable);
1919 }
1920 
1921 void ScInterpreter::PushNoValue()
1922 {
1923  PushError( FormulaError::NoValue);
1924 }
1925 
1926 bool ScInterpreter::IsMissing() const
1927 {
1928  return sp && pStack[sp - 1]->GetType() == svMissing;
1929 }
1930 
1931 StackVar ScInterpreter::GetRawStackType()
1932 {
1933  StackVar eRes;
1934  if( sp )
1935  {
1936  eRes = pStack[sp - 1]->GetType();
1937  }
1938  else
1939  {
1940  SetError(FormulaError::UnknownStackVariable);
1941  eRes = svUnknown;
1942  }
1943  return eRes;
1944 }
1945 
1946 StackVar ScInterpreter::GetStackType()
1947 {
1948  StackVar eRes;
1949  if( sp )
1950  {
1951  eRes = pStack[sp - 1]->GetType();
1952  if( eRes == svMissing || eRes == svEmptyCell )
1953  eRes = svDouble; // default!
1954  }
1955  else
1956  {
1957  SetError(FormulaError::UnknownStackVariable);
1958  eRes = svUnknown;
1959  }
1960  return eRes;
1961 }
1962 
1963 StackVar ScInterpreter::GetStackType( sal_uInt8 nParam )
1964 {
1965  StackVar eRes;
1966  if( sp > nParam-1 )
1967  {
1968  eRes = pStack[sp - nParam]->GetType();
1969  if( eRes == svMissing || eRes == svEmptyCell )
1970  eRes = svDouble; // default!
1971  }
1972  else
1973  eRes = svUnknown;
1974  return eRes;
1975 }
1976 
1977 void ScInterpreter::ReverseStack( sal_uInt8 nParamCount )
1978 {
1979  //reverse order of parameter stack
1980  assert( sp >= nParamCount && " less stack elements than parameters");
1981  sal_uInt16 nStackParams = std::min<sal_uInt16>( sp, nParamCount);
1982  std::reverse( pStack+(sp-nStackParams), pStack+sp );
1983 }
1984 
1985 bool ScInterpreter::DoubleRefToPosSingleRef( const ScRange& rRange, ScAddress& rAdr )
1986 {
1987  // Check for a singleton first - no implicit intersection for them.
1988  if( rRange.aStart == rRange.aEnd )
1989  {
1990  rAdr = rRange.aStart;
1991  return true;
1992  }
1993 
1994  bool bOk = false;
1995 
1996  if ( pJumpMatrix )
1997  {
1998  bOk = rRange.aStart.Tab() == rRange.aEnd.Tab();
1999  if ( !bOk )
2000  SetError( FormulaError::IllegalArgument);
2001  else
2002  {
2003  SCSIZE nC, nR;
2004  pJumpMatrix->GetPos( nC, nR);
2005  rAdr.SetCol( sal::static_int_cast<SCCOL>( rRange.aStart.Col() + nC ) );
2006  rAdr.SetRow( sal::static_int_cast<SCROW>( rRange.aStart.Row() + nR ) );
2007  rAdr.SetTab( rRange.aStart.Tab());
2008  bOk = rRange.aStart.Col() <= rAdr.Col() && rAdr.Col() <=
2009  rRange.aEnd.Col() && rRange.aStart.Row() <= rAdr.Row() &&
2010  rAdr.Row() <= rRange.aEnd.Row();
2011  if ( !bOk )
2012  SetError( FormulaError::NoValue);
2013  }
2014  return bOk;
2015  }
2016 
2017  bOk = ScCompiler::DoubleRefToPosSingleRefScalarCase(rRange, rAdr, aPos);
2018 
2019  if ( !bOk )
2020  SetError( FormulaError::NoValue );
2021  return bOk;
2022 }
2023 
2024 double ScInterpreter::GetDoubleFromMatrix(const ScMatrixRef& pMat)
2025 {
2026  if (!pMat)
2027  return 0.0;
2028 
2029  if ( !pJumpMatrix )
2030  {
2031  double fVal = pMat->GetDoubleWithStringConversion( 0, 0);
2032  FormulaError nErr = GetDoubleErrorValue( fVal);
2033  if (nErr != FormulaError::NONE)
2034  {
2035  // Do not propagate the coded double error, but set nGlobalError in
2036  // case the matrix did not have an error interpreter set.
2037  SetError( nErr);
2038  fVal = 0.0;
2039  }
2040  return fVal;
2041  }
2042 
2043  SCSIZE nCols, nRows, nC, nR;
2044  pMat->GetDimensions( nCols, nRows);
2045  pJumpMatrix->GetPos( nC, nR);
2046  // Use vector replication for single row/column arrays.
2047  if ( (nC < nCols || nCols == 1) && (nR < nRows || nRows == 1) )
2048  {
2049  double fVal = pMat->GetDoubleWithStringConversion( nC, nR);
2050  FormulaError nErr = GetDoubleErrorValue( fVal);
2051  if (nErr != FormulaError::NONE)
2052  {
2053  // Do not propagate the coded double error, but set nGlobalError in
2054  // case the matrix did not have an error interpreter set.
2055  SetError( nErr);
2056  fVal = 0.0;
2057  }
2058  return fVal;
2059  }
2060 
2061  SetError( FormulaError::NoValue);
2062  return 0.0;
2063 }
2064 
2065 double ScInterpreter::GetDouble()
2066 {
2067  double nVal(0.0);
2068  switch( GetRawStackType() )
2069  {
2070  case svDouble:
2071  nVal = PopDouble();
2072  break;
2073  case svString:
2074  nVal = ConvertStringToValue( PopString().getString());
2075  break;
2076  case svSingleRef:
2077  {
2078  ScAddress aAdr;
2079  PopSingleRef( aAdr );
2080  ScRefCellValue aCell(mrDoc, aAdr);
2081  nVal = GetCellValue(aAdr, aCell);
2082  }
2083  break;
2084  case svDoubleRef:
2085  { // generate position dependent SingleRef
2086  ScRange aRange;
2087  PopDoubleRef( aRange );
2088  ScAddress aAdr;
2089  if ( nGlobalError == FormulaError::NONE && DoubleRefToPosSingleRef( aRange, aAdr ) )
2090  {
2091  ScRefCellValue aCell(mrDoc, aAdr);
2092  nVal = GetCellValue(aAdr, aCell);
2093  }
2094  else
2095  nVal = 0.0;
2096  }
2097  break;
2098  case svExternalSingleRef:
2099  {
2100  ScExternalRefCache::TokenRef pToken;
2101  PopExternalSingleRef(pToken);
2102  if (nGlobalError == FormulaError::NONE)
2103  {
2104  if (pToken->GetType() == svDouble || pToken->GetType() == svEmptyCell)
2105  nVal = pToken->GetDouble();
2106  else
2107  nVal = ConvertStringToValue( pToken->GetString().getString());
2108  }
2109  }
2110  break;
2111  case svExternalDoubleRef:
2112  {
2113  ScMatrixRef pMat;
2114  PopExternalDoubleRef(pMat);
2115  if (nGlobalError != FormulaError::NONE)
2116  break;
2117 
2118  nVal = GetDoubleFromMatrix(pMat);
2119  }
2120  break;
2121  case svMatrix:
2122  {
2123  ScMatrixRef pMat = PopMatrix();
2124  nVal = GetDoubleFromMatrix(pMat);
2125  }
2126  break;
2127  case svError:
2128  PopError();
2129  nVal = 0.0;
2130  break;
2131  case svEmptyCell:
2132  case svMissing:
2133  Pop();
2134  nVal = 0.0;
2135  break;
2136  default:
2137  PopError();
2138  SetError( FormulaError::IllegalParameter);
2139  nVal = 0.0;
2140  }
2141  if ( nFuncFmtType == nCurFmtType )
2142  nFuncFmtIndex = nCurFmtIndex;
2143  return nVal;
2144 }
2145 
2146 double ScInterpreter::GetDoubleWithDefault(double nDefault)
2147 {
2148  bool bMissing = IsMissing();
2149  double nResultVal = GetDouble();
2150  if ( bMissing )
2151  nResultVal = nDefault;
2152  return nResultVal;
2153 }
2154 
2155 sal_Int32 ScInterpreter::double_to_int32(double fVal)
2156 {
2157  if (!std::isfinite(fVal))
2158  {
2159  SetError( GetDoubleErrorValue( fVal));
2160  return SAL_MAX_INT32;
2161  }
2162  if (fVal > 0.0)
2163  {
2164  fVal = rtl::math::approxFloor( fVal);
2165  if (fVal > SAL_MAX_INT32)
2166  {
2167  SetError( FormulaError::IllegalArgument);
2168  return SAL_MAX_INT32;
2169  }
2170  }
2171  else if (fVal < 0.0)
2172  {
2173  fVal = rtl::math::approxCeil( fVal);
2174  if (fVal < SAL_MIN_INT32)
2175  {
2176  SetError( FormulaError::IllegalArgument);
2177  return SAL_MAX_INT32;
2178  }
2179  }
2180  return static_cast<sal_Int32>(fVal);
2181 }
2182 
2183 sal_Int32 ScInterpreter::GetInt32()
2184 {
2185  return double_to_int32(GetDouble());
2186 }
2187 
2188 sal_Int32 ScInterpreter::GetInt32WithDefault( sal_Int32 nDefault )
2189 {
2190  bool bMissing = IsMissing();
2191  double fVal = GetDouble();
2192  if ( bMissing )
2193  return nDefault;
2194  return double_to_int32(fVal);
2195 }
2196 
2197 sal_Int16 ScInterpreter::GetInt16()
2198 {
2199  double fVal = GetDouble();
2200  if (!std::isfinite(fVal))
2201  {
2202  SetError( GetDoubleErrorValue( fVal));
2203  return SAL_MAX_INT16;
2204  }
2205  if (fVal > 0.0)
2206  {
2207  fVal = rtl::math::approxFloor( fVal);
2208  if (fVal > SAL_MAX_INT16)
2209  {
2210  SetError( FormulaError::IllegalArgument);
2211  return SAL_MAX_INT16;
2212  }
2213  }
2214  else if (fVal < 0.0)
2215  {
2216  fVal = rtl::math::approxCeil( fVal);
2217  if (fVal < SAL_MIN_INT16)
2218  {
2219  SetError( FormulaError::IllegalArgument);
2220  return SAL_MAX_INT16;
2221  }
2222  }
2223  return static_cast<sal_Int16>(fVal);
2224 }
2225 
2226 sal_uInt32 ScInterpreter::GetUInt32()
2227 {
2228  double fVal = rtl::math::approxFloor( GetDouble());
2229  if (!std::isfinite(fVal))
2230  {
2231  SetError( GetDoubleErrorValue( fVal));
2232  return SAL_MAX_UINT32;
2233  }
2234  if (fVal < 0.0 || fVal > SAL_MAX_UINT32)
2235  {
2236  SetError( FormulaError::IllegalArgument);
2237  return SAL_MAX_UINT32;
2238  }
2239  return static_cast<sal_uInt32>(fVal);
2240 }
2241 
2242 bool ScInterpreter::GetDoubleOrString( double& rDouble, svl::SharedString& rString )
2243 {
2244  bool bDouble = true;
2245  switch( GetRawStackType() )
2246  {
2247  case svDouble:
2248  rDouble = PopDouble();
2249  break;
2250  case svString:
2251  rString = PopString();
2252  bDouble = false;
2253  break;
2254  case svDoubleRef :
2255  case svSingleRef :
2256  {
2257  ScAddress aAdr;
2258  if (!PopDoubleRefOrSingleRef( aAdr))
2259  {
2260  rDouble = 0.0;
2261  return true; // caller needs to check nGlobalError
2262  }
2263  ScRefCellValue aCell( mrDoc, aAdr);
2264  if (aCell.hasNumeric())
2265  {
2266  rDouble = GetCellValue( aAdr, aCell);
2267  }
2268  else
2269  {
2270  GetCellString( rString, aCell);
2271  bDouble = false;
2272  }
2273  }
2274  break;
2275  case svExternalSingleRef:
2276  case svExternalDoubleRef:
2277  case svMatrix:
2278  {
2279  ScMatValType nType = GetDoubleOrStringFromMatrix( rDouble, rString);
2280  bDouble = ScMatrix::IsValueType( nType);
2281  }
2282  break;
2283  case svError:
2284  PopError();
2285  rDouble = 0.0;
2286  break;
2287  case svEmptyCell:
2288  case svMissing:
2289  Pop();
2290  rDouble = 0.0;
2291  break;
2292  default:
2293  PopError();
2294  SetError( FormulaError::IllegalParameter);
2295  rDouble = 0.0;
2296  }
2297  if ( nFuncFmtType == nCurFmtType )
2298  nFuncFmtIndex = nCurFmtIndex;
2299  return bDouble;
2300 }
2301 
2302 svl::SharedString ScInterpreter::GetString()
2303 {
2304  switch (GetRawStackType())
2305  {
2306  case svError:
2307  PopError();
2308  return svl::SharedString::getEmptyString();
2309  case svMissing:
2310  case svEmptyCell:
2311  Pop();
2312  return svl::SharedString::getEmptyString();
2313  case svDouble:
2314  {
2315  return GetStringFromDouble( PopDouble() );
2316  }
2317  case svString:
2318  return PopString();
2319  case svSingleRef:
2320  {
2321  ScAddress aAdr;
2322  PopSingleRef( aAdr );
2323  if (nGlobalError == FormulaError::NONE)
2324  {
2325  ScRefCellValue aCell(mrDoc, aAdr);
2326  svl::SharedString aSS;
2327  GetCellString(aSS, aCell);
2328  return aSS;
2329  }
2330  else
2331  return svl::SharedString::getEmptyString();
2332  }
2333  case svDoubleRef:
2334  { // generate position dependent SingleRef
2335  ScRange aRange;
2336  PopDoubleRef( aRange );
2337  ScAddress aAdr;
2338  if ( nGlobalError == FormulaError::NONE && DoubleRefToPosSingleRef( aRange, aAdr ) )
2339  {
2340  ScRefCellValue aCell(mrDoc, aAdr);
2341  svl::SharedString aSS;
2342  GetCellString(aSS, aCell);
2343  return aSS;
2344  }
2345  else
2346  return svl::SharedString::getEmptyString();
2347  }
2348  case svExternalSingleRef:
2349  {
2350  ScExternalRefCache::TokenRef pToken;
2351  PopExternalSingleRef(pToken);
2352  if (nGlobalError != FormulaError::NONE)
2353  return svl::SharedString::getEmptyString();
2354 
2355  if (pToken->GetType() == svDouble)
2356  {
2357  return GetStringFromDouble( pToken->GetDouble() );
2358  }
2359  else // svString or svEmpty
2360  return pToken->GetString();
2361  }
2362  case svExternalDoubleRef:
2363  {
2364  ScMatrixRef pMat;
2365  PopExternalDoubleRef(pMat);
2366  return GetStringFromMatrix(pMat);
2367  }
2368  case svMatrix:
2369  {
2370  ScMatrixRef pMat = PopMatrix();
2371  return GetStringFromMatrix(pMat);
2372  }
2373  break;
2374  default:
2375  PopError();
2376  SetError( FormulaError::IllegalArgument);
2377  }
2378  return svl::SharedString::getEmptyString();
2379 }
2380 
2381 svl::SharedString ScInterpreter::GetStringFromMatrix(const ScMatrixRef& pMat)
2382 {
2383  if ( !pMat )
2384  ; // nothing
2385  else if ( !pJumpMatrix )
2386  {
2387  return pMat->GetString( *pFormatter, 0, 0);
2388  }
2389  else
2390  {
2391  SCSIZE nCols, nRows, nC, nR;
2392  pMat->GetDimensions( nCols, nRows);
2393  pJumpMatrix->GetPos( nC, nR);
2394  // Use vector replication for single row/column arrays.
2395  if ( (nC < nCols || nCols == 1) && (nR < nRows || nRows == 1) )
2396  return pMat->GetString( *pFormatter, nC, nR);
2397 
2398  SetError( FormulaError::NoValue);
2399  }
2400  return svl::SharedString::getEmptyString();
2401 }
2402 
2403 ScMatValType ScInterpreter::GetDoubleOrStringFromMatrix(
2404  double& rDouble, svl::SharedString& rString )
2405 {
2406 
2407  rDouble = 0.0;
2408  rString = svl::SharedString::getEmptyString();
2409  ScMatValType nMatValType = ScMatValType::Empty;
2410 
2411  ScMatrixRef pMat;
2412  StackVar eType = GetStackType();
2413  if (eType == svExternalDoubleRef || eType == svExternalSingleRef || eType == svMatrix)
2414  {
2415  pMat = GetMatrix();
2416  }
2417  else
2418  {
2419  PopError();
2420  SetError( FormulaError::IllegalParameter);
2421  return nMatValType;
2422  }
2423 
2424  ScMatrixValue nMatVal;
2425  if (!pMat)
2426  {
2427  // nothing
2428  }
2429  else if (!pJumpMatrix)
2430  {
2431  nMatVal = pMat->Get(0, 0);
2432  nMatValType = nMatVal.nType;
2433  }
2434  else
2435  {
2436  SCSIZE nCols, nRows, nC, nR;
2437  pMat->GetDimensions( nCols, nRows);
2438  pJumpMatrix->GetPos( nC, nR);
2439  // Use vector replication for single row/column arrays.
2440  if ( (nC < nCols || nCols == 1) && (nR < nRows || nRows == 1) )
2441  {
2442  nMatVal = pMat->Get( nC, nR);
2443  nMatValType = nMatVal.nType;
2444  }
2445  else
2446  SetError( FormulaError::NoValue);
2447  }
2448 
2449  if (ScMatrix::IsValueType( nMatValType))
2450  {
2451  rDouble = nMatVal.fVal;
2452  FormulaError nError = nMatVal.GetError();
2453  if (nError != FormulaError::NONE)
2454  SetError( nError);
2455  }
2456  else
2457  {
2458  rString = nMatVal.GetString();
2459  }
2460 
2461  return nMatValType;
2462 }
2463 
2464 svl::SharedString ScInterpreter::GetStringFromDouble( double fVal )
2465 {
2466  sal_uLong nIndex = pFormatter->GetStandardFormat(
2467  SvNumFormatType::NUMBER,
2468  ScGlobal::eLnge);
2469  OUString aStr;
2470  pFormatter->GetInputLineString(fVal, nIndex, aStr);
2471  return mrStrPool.intern(aStr);
2472 }
2473 
2474 void ScInterpreter::ScDBGet()
2475 {
2476  bool bMissingField = false;
2477  unique_ptr<ScDBQueryParamBase> pQueryParam( GetDBParams(bMissingField) );
2478  if (!pQueryParam)
2479  {
2480  // Failed to create query param.
2481  PushIllegalParameter();
2482  return;
2483  }
2484 
2485  pQueryParam->mbSkipString = false;
2486  ScDBQueryDataIterator aValIter(mrDoc, mrContext, std::move(pQueryParam));
2487  ScDBQueryDataIterator::Value aValue;
2488  if (!aValIter.GetFirst(aValue) || aValue.mnError != FormulaError::NONE)
2489  {
2490  // No match found.
2491  PushNoValue();
2492  return;
2493  }
2494 
2495  ScDBQueryDataIterator::Value aValNext;
2496  if (aValIter.GetNext(aValNext) && aValNext.mnError == FormulaError::NONE)
2497  {
2498  // There should be only one unique match.
2499  PushIllegalArgument();
2500  return;
2501  }
2502 
2503  if (aValue.mbIsNumber)
2504  PushDouble(aValue.mfValue);
2505  else
2506  PushString(aValue.maString);
2507 }
2508 
2509 void ScInterpreter::ScExternal()
2510 {
2511  sal_uInt8 nParamCount = GetByte();
2512  OUString aUnoName;
2513  OUString aFuncName( ScGlobal::getCharClassPtr()->uppercase( pCur->GetExternal() ) );
2514  LegacyFuncData* pLegacyFuncData = ScGlobal::GetLegacyFuncCollection()->findByName(aFuncName);
2515  if (pLegacyFuncData)
2516  {
2517  // Old binary non-UNO add-in function.
2518  // NOTE: parameter count is 1-based with the 0th "parameter" being the
2519  // return value, included in pLegacyFuncDatat->GetParamCount()
2520  if (nParamCount < MAXFUNCPARAM && nParamCount == pLegacyFuncData->GetParamCount() - 1)
2521  {
2522  ParamType eParamType[MAXFUNCPARAM];
2523  void* ppParam[MAXFUNCPARAM];
2524  double nVal[MAXFUNCPARAM];
2525  char* pStr[MAXFUNCPARAM];
2526  sal_uInt8* pCellArr[MAXFUNCPARAM];
2527  short i;
2528 
2529  for (i = 0; i < MAXFUNCPARAM; i++)
2530  {
2531  eParamType[i] = pLegacyFuncData->GetParamType(i);
2532  ppParam[i] = nullptr;
2533  nVal[i] = 0.0;
2534  pStr[i] = nullptr;
2535  pCellArr[i] = nullptr;
2536  }
2537 
2538  for (i = nParamCount; (i > 0) && (nGlobalError == FormulaError::NONE); i--)
2539  {
2540  if (IsMissing())
2541  {
2542  // Old binary Add-In can't distinguish between missing
2543  // omitted argument and 0 (or any other value). Force
2544  // error.
2545  SetError( FormulaError::ParameterExpected);
2546  break; // for
2547  }
2548  switch (eParamType[i])
2549  {
2550  case ParamType::PTR_DOUBLE :
2551  {
2552  nVal[i-1] = GetDouble();
2553  ppParam[i] = &nVal[i-1];
2554  }
2555  break;
2556  case ParamType::PTR_STRING :
2557  {
2558  OString aStr(OUStringToOString(GetString().getString(),
2559  osl_getThreadTextEncoding()));
2560  if ( aStr.getLength() >= ADDIN_MAXSTRLEN )
2561  SetError( FormulaError::StringOverflow );
2562  else
2563  {
2564  pStr[i-1] = new char[ADDIN_MAXSTRLEN];
2565  strncpy( pStr[i-1], aStr.getStr(), ADDIN_MAXSTRLEN );
2566  pStr[i-1][ADDIN_MAXSTRLEN-1] = 0;
2567  ppParam[i] = pStr[i-1];
2568  }
2569  }
2570  break;
2571  case ParamType::PTR_DOUBLE_ARR :
2572  {
2573  SCCOL nCol1;
2574  SCROW nRow1;
2575  SCTAB nTab1;
2576  SCCOL nCol2;
2577  SCROW nRow2;
2578  SCTAB nTab2;
2579  PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2580  pCellArr[i-1] = new sal_uInt8[MAXARRSIZE];
2581  if (!CreateDoubleArr(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, pCellArr[i-1]))
2582  SetError(FormulaError::CodeOverflow);
2583  else
2584  ppParam[i] = pCellArr[i-1];
2585  }
2586  break;
2587  case ParamType::PTR_STRING_ARR :
2588  {
2589  SCCOL nCol1;
2590  SCROW nRow1;
2591  SCTAB nTab1;
2592  SCCOL nCol2;
2593  SCROW nRow2;
2594  SCTAB nTab2;
2595  PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2596  pCellArr[i-1] = new sal_uInt8[MAXARRSIZE];
2597  if (!CreateStringArr(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, pCellArr[i-1]))
2598  SetError(FormulaError::CodeOverflow);
2599  else
2600  ppParam[i] = pCellArr[i-1];
2601  }
2602  break;
2603  case ParamType::PTR_CELL_ARR :
2604  {
2605  SCCOL nCol1;
2606  SCROW nRow1;
2607  SCTAB nTab1;
2608  SCCOL nCol2;
2609  SCROW nRow2;
2610  SCTAB nTab2;
2611  PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2612  pCellArr[i-1] = new sal_uInt8[MAXARRSIZE];
2613  if (!CreateCellArr(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, pCellArr[i-1]))
2614  SetError(FormulaError::CodeOverflow);
2615  else
2616  ppParam[i] = pCellArr[i-1];
2617  }
2618  break;
2619  default :
2620  SetError(FormulaError::IllegalParameter);
2621  break;
2622  }
2623  }
2624  while ( i-- )
2625  Pop(); // In case of error (otherwise i==0) pop all parameters
2626 
2627  if (nGlobalError == FormulaError::NONE)
2628  {
2629  if ( pLegacyFuncData->GetAsyncType() == ParamType::NONE )
2630  {
2631  switch ( eParamType[0] )
2632  {
2633  case ParamType::PTR_DOUBLE :
2634  {
2635  double nErg = 0.0;
2636  ppParam[0] = &nErg;
2637  pLegacyFuncData->Call(ppParam);
2638  PushDouble(nErg);
2639  }
2640  break;
2641  case ParamType::PTR_STRING :
2642  {
2643  std::unique_ptr<char[]> pcErg(new char[ADDIN_MAXSTRLEN]);
2644  ppParam[0] = pcErg.get();
2645  pLegacyFuncData->Call(ppParam);
2646  OUString aUni( pcErg.get(), strlen(pcErg.get()), osl_getThreadTextEncoding() );
2647  PushString( aUni );
2648  }
2649  break;
2650  default:
2651  PushError( FormulaError::UnknownState );
2652  }
2653  }
2654  else
2655  {
2656  // enable asyncs after loading
2657  pArr->AddRecalcMode( ScRecalcMode::ONLOAD_LENIENT );
2658  // assure identical handler with identical call?
2659  double nErg = 0.0;
2660  ppParam[0] = &nErg;
2661  pLegacyFuncData->Call(ppParam);
2662  sal_uLong nHandle = sal_uLong( nErg );
2663  if ( nHandle >= 65536 )
2664  {
2665  ScAddInAsync* pAs = ScAddInAsync::Get( nHandle );
2666  if ( !pAs )
2667  {
2668  pAs = new ScAddInAsync(nHandle, pLegacyFuncData, &mrDoc);
2669  pMyFormulaCell->StartListening( *pAs );
2670  }
2671  else
2672  {
2673  pMyFormulaCell->StartListening( *pAs );
2674  if ( !pAs->HasDocument( &mrDoc ) )
2675  pAs->AddDocument( &mrDoc );
2676  }
2677  if ( pAs->IsValid() )
2678  {
2679  switch ( pAs->GetType() )
2680  {
2681  case ParamType::PTR_DOUBLE :
2682  PushDouble( pAs->GetValue() );
2683  break;
2684  case ParamType::PTR_STRING :
2685  PushString( pAs->GetString() );
2686  break;
2687  default:
2688  PushError( FormulaError::UnknownState );
2689  }
2690  }
2691  else
2692  PushNA();
2693  }
2694  else
2695  PushNoValue();
2696  }
2697  }
2698 
2699  for (i = 0; i < MAXFUNCPARAM; i++)
2700  {
2701  delete[] pStr[i];
2702  delete[] pCellArr[i];
2703  }
2704  }
2705  else
2706  {
2707  while( nParamCount-- > 0)
2708  Pop();
2709  PushIllegalParameter();
2710  }
2711  }
2712  else if ( !( aUnoName = ScGlobal::GetAddInCollection()->FindFunction(aFuncName, false) ).isEmpty() )
2713  {
2714  // bLocalFirst=false in FindFunction, cFunc should be the stored
2715  // internal name
2716 
2717  ScUnoAddInCall aCall( *ScGlobal::GetAddInCollection(), aUnoName, nParamCount );
2718 
2719  if ( !aCall.ValidParamCount() )
2720  SetError( FormulaError::IllegalParameter );
2721 
2722  if ( aCall.NeedsCaller() && GetError() == FormulaError::NONE )
2723  {
2724  SfxObjectShell* pShell = mrDoc.GetDocumentShell();
2725  if (pShell)
2726  aCall.SetCallerFromObjectShell( pShell );
2727  else
2728  {
2729  // use temporary model object (without document) to supply options
2730  aCall.SetCaller( static_cast<beans::XPropertySet*>(
2731  new ScDocOptionsObj( mrDoc.GetDocOptions() ) ) );
2732  }
2733  }
2734 
2735  short nPar = nParamCount;
2736  while ( nPar > 0 && GetError() == FormulaError::NONE )
2737  {
2738  --nPar; // 0 .. (nParamCount-1)
2739 
2740  uno::Any aParam;
2741  if (IsMissing())
2742  {
2743  // Add-In has to explicitly handle an omitted empty missing
2744  // argument, do not default to anything like GetDouble() would
2745  // do (e.g. 0).
2746  Pop();
2747  aCall.SetParam( nPar, aParam );
2748  continue; // while
2749  }
2750 
2751  StackVar nStackType = GetStackType();
2752  ScAddInArgumentType eType = aCall.GetArgType( nPar );
2753  switch (eType)
2754  {
2755  case SC_ADDINARG_INTEGER:
2756  {
2757  sal_Int32 nVal = GetInt32();
2758  if (nGlobalError == FormulaError::NONE)
2759  aParam <<= nVal;
2760  }
2761  break;
2762 
2763  case SC_ADDINARG_DOUBLE:
2764  aParam <<= GetDouble();
2765  break;
2766 
2767  case SC_ADDINARG_STRING:
2768  aParam <<= GetString().getString();
2769  break;
2770 
2771  case SC_ADDINARG_INTEGER_ARRAY:
2772  switch( nStackType )
2773  {
2774  case svDouble:
2775  case svString:
2776  case svSingleRef:
2777  {
2778  sal_Int32 nVal = GetInt32();
2779  if (nGlobalError == FormulaError::NONE)
2780  {
2781  uno::Sequence<sal_Int32> aInner( &nVal, 1 );
2782  uno::Sequence< uno::Sequence<sal_Int32> > aOuter( &aInner, 1 );
2783  aParam <<= aOuter;
2784  }
2785  }
2786  break;
2787  case svDoubleRef:
2788  {
2789  ScRange aRange;
2790  PopDoubleRef( aRange );
2791  if (!ScRangeToSequence::FillLongArray( aParam, mrDoc, aRange ))
2792  SetError(FormulaError::IllegalParameter);
2793  }
2794  break;
2795  case svMatrix:
2796  if (!ScRangeToSequence::FillLongArray( aParam, PopMatrix().get() ))
2797  SetError(FormulaError::IllegalParameter);
2798  break;
2799  default:
2800  PopError();
2801  SetError(FormulaError::IllegalParameter);
2802  }
2803  break;
2804 
2805  case SC_ADDINARG_DOUBLE_ARRAY:
2806  switch( nStackType )
2807  {
2808  case svDouble:
2809  case svString:
2810  case svSingleRef:
2811  {
2812  double fVal = GetDouble();
2813  uno::Sequence<double> aInner( &fVal, 1 );
2814  uno::Sequence< uno::Sequence<double> > aOuter( &aInner, 1 );
2815  aParam <<= aOuter;
2816  }
2817  break;
2818  case svDoubleRef:
2819  {
2820  ScRange aRange;
2821  PopDoubleRef( aRange );
2822  if (!ScRangeToSequence::FillDoubleArray( aParam, mrDoc, aRange ))
2823  SetError(FormulaError::IllegalParameter);
2824  }
2825  break;
2826  case svMatrix:
2827  if (!ScRangeToSequence::FillDoubleArray( aParam, PopMatrix().get() ))
2828  SetError(FormulaError::IllegalParameter);
2829  break;
2830  default:
2831  PopError();
2832  SetError(FormulaError::IllegalParameter);
2833  }
2834  break;
2835 
2836  case SC_ADDINARG_STRING_ARRAY:
2837  switch( nStackType )
2838  {
2839  case svDouble:
2840  case svString:
2841  case svSingleRef:
2842  {
2843  OUString aString = GetString().getString();
2844  uno::Sequence<OUString> aInner( &aString, 1 );
2845  uno::Sequence< uno::Sequence<OUString> > aOuter( &aInner, 1 );
2846  aParam <<= aOuter;
2847  }
2848  break;
2849  case svDoubleRef:
2850  {
2851  ScRange aRange;
2852  PopDoubleRef( aRange );
2853  if (!ScRangeToSequence::FillStringArray( aParam, mrDoc, aRange ))
2854  SetError(FormulaError::IllegalParameter);
2855  }
2856  break;
2857  case svMatrix:
2858  if (!ScRangeToSequence::FillStringArray( aParam, PopMatrix().get(), pFormatter ))
2859  SetError(FormulaError::IllegalParameter);
2860  break;
2861  default:
2862  PopError();
2863  SetError(FormulaError::IllegalParameter);
2864  }
2865  break;
2866 
2867  case SC_ADDINARG_MIXED_ARRAY:
2868  switch( nStackType )
2869  {
2870  case svDouble:
2871  case svString:
2872  case svSingleRef:
2873  {
2874  uno::Any aElem;
2875  if ( nStackType == svDouble )
2876  aElem <<= GetDouble();
2877  else if ( nStackType == svString )
2878  aElem <<= GetString().getString();
2879  else
2880  {
2881  ScAddress aAdr;
2882  if ( PopDoubleRefOrSingleRef( aAdr ) )
2883  {
2884  ScRefCellValue aCell(mrDoc, aAdr);
2885  if (aCell.hasString())
2886  {
2887  svl::SharedString aStr;
2888  GetCellString(aStr, aCell);
2889  aElem <<= aStr.getString();
2890  }
2891  else
2892  aElem <<= GetCellValue(aAdr, aCell);
2893  }
2894  }
2895  uno::Sequence<uno::Any> aInner( &aElem, 1 );
2896  uno::Sequence< uno::Sequence<uno::Any> > aOuter( &aInner, 1 );
2897  aParam <<= aOuter;
2898  }
2899  break;
2900  case svDoubleRef:
2901  {
2902  ScRange aRange;
2903  PopDoubleRef( aRange );
2904  if (!ScRangeToSequence::FillMixedArray( aParam, mrDoc, aRange ))
2905  SetError(FormulaError::IllegalParameter);
2906  }
2907  break;
2908  case svMatrix:
2909  if (!ScRangeToSequence::FillMixedArray( aParam, PopMatrix().get() ))
2910  SetError(FormulaError::IllegalParameter);
2911  break;
2912  default:
2913  PopError();
2914  SetError(FormulaError::IllegalParameter);
2915  }
2916  break;
2917 
2918  case SC_ADDINARG_VALUE_OR_ARRAY:
2919  switch( nStackType )
2920  {
2921  case svDouble:
2922  aParam <<= GetDouble();
2923  break;
2924  case svString:
2925  aParam <<= GetString().getString();
2926  break;
2927  case svSingleRef:
2928  {
2929  ScAddress aAdr;
2930  if ( PopDoubleRefOrSingleRef( aAdr ) )
2931  {
2932  ScRefCellValue aCell(mrDoc, aAdr);
2933  if (aCell.hasString())
2934  {
2935  svl::SharedString aStr;
2936  GetCellString(aStr, aCell);
2937  aParam <<= aStr.getString();
2938  }
2939  else
2940  aParam <<= GetCellValue(aAdr, aCell);
2941  }
2942  }
2943  break;
2944  case svDoubleRef:
2945  {
2946  ScRange aRange;
2947  PopDoubleRef( aRange );
2948  if (!ScRangeToSequence::FillMixedArray( aParam, mrDoc, aRange ))
2949  SetError(FormulaError::IllegalParameter);
2950  }
2951  break;
2952  case svMatrix:
2953  if (!ScRangeToSequence::FillMixedArray( aParam, PopMatrix().get() ))
2954  SetError(FormulaError::IllegalParameter);
2955  break;
2956  default:
2957  PopError();
2958  SetError(FormulaError::IllegalParameter);
2959  }
2960  break;
2961 
2962  case SC_ADDINARG_CELLRANGE:
2963  switch( nStackType )
2964  {
2965  case svSingleRef:
2966  {
2967  ScAddress aAdr;
2968  PopSingleRef( aAdr );
2969  ScRange aRange( aAdr );
2970  uno::Reference<table::XCellRange> xObj =
2971  ScCellRangeObj::CreateRangeFromDoc( mrDoc, aRange );
2972  if (xObj.is())
2973  aParam <<= xObj;
2974  else
2975  SetError(FormulaError::IllegalParameter);
2976  }
2977  break;
2978  case svDoubleRef:
2979  {
2980  ScRange aRange;
2981  PopDoubleRef( aRange );
2982  uno::Reference<table::XCellRange> xObj =
2983  ScCellRangeObj::CreateRangeFromDoc( mrDoc, aRange );
2984  if (xObj.is())
2985  {
2986  aParam <<= xObj;
2987  }
2988  else
2989  {
2990  SetError(FormulaError::IllegalParameter);
2991  }
2992  }
2993  break;
2994  default:
2995  PopError();
2996  SetError(FormulaError::IllegalParameter);
2997  }
2998  break;
2999 
3000  default:
3001  PopError();
3002  SetError(FormulaError::IllegalParameter);
3003  }
3004  aCall.SetParam( nPar, aParam );
3005  }
3006 
3007  while (nPar-- > 0)
3008  {
3009  Pop(); // in case of error, remove remaining args
3010  }
3011  if ( GetError() == FormulaError::NONE )
3012  {
3013  aCall.ExecuteCall();
3014 
3015  if ( aCall.HasVarRes() ) // handle async functions
3016  {
3017  pArr->AddRecalcMode( ScRecalcMode::ONLOAD_LENIENT );
3018  uno::Reference<sheet::XVolatileResult> xRes = aCall.GetVarRes();
3019  ScAddInListener* pLis = ScAddInListener::Get( xRes );
3020  // In case there is no pMyFormulaCell, i.e. while interpreting
3021  // temporarily from within the Function Wizard, try to obtain a
3022  // valid result from an existing listener for that volatile, or
3023  // create a new and hope for an immediate result. If none
3024  // available that should lead to a void result and thus #N/A.
3025  bool bTemporaryListener = false;
3026  if ( !pLis )
3027  {
3028  pLis = ScAddInListener::CreateListener( xRes, &mrDoc );
3029  if (pMyFormulaCell)
3030  pMyFormulaCell->StartListening( *pLis );
3031  else
3032  bTemporaryListener = true;
3033  }
3034  else if (pMyFormulaCell)
3035  {
3036  pMyFormulaCell->StartListening( *pLis );
3037  if ( !pLis->HasDocument( &mrDoc ) )
3038  {
3039  pLis->AddDocument( &mrDoc );
3040  }
3041  }
3042 
3043  aCall.SetResult( pLis->GetResult() ); // use result from async
3044 
3045  if (bTemporaryListener)
3046  {
3047  try
3048  {
3049  // EventObject can be any, not evaluated by
3050  // ScAddInListener::disposing()
3051  css::lang::EventObject aEvent;
3052  pLis->disposing(aEvent); // pLis is dead hereafter
3053  }
3054  catch (const uno::Exception&)
3055  {
3056  }
3057  }
3058  }
3059 
3060  if ( aCall.GetErrCode() != FormulaError::NONE )
3061  {
3062  PushError( aCall.GetErrCode() );
3063  }
3064  else if ( aCall.HasMatrix() )
3065  {
3066  PushMatrix( aCall.GetMatrix() );
3067  }
3068  else if ( aCall.HasString() )
3069  {
3070  PushString( aCall.GetString() );
3071  }
3072  else
3073  {
3074  PushDouble( aCall.GetValue() );
3075  }
3076  }
3077  else // error...
3078  PushError( GetError());
3079  }
3080  else
3081  {
3082  while( nParamCount-- > 0)
3083  {
3084  Pop();
3085  }
3086  PushError( FormulaError::NoAddin );
3087  }
3088 }
3089 
3090 void ScInterpreter::ScMissing()
3091 {
3092  if ( aCode.IsEndOfPath() )
3093  PushTempToken( new ScEmptyCellToken( false, false ) );
3094  else
3095  PushTempToken( new FormulaMissingToken );
3096 }
3097 
3098 #if HAVE_FEATURE_SCRIPTING
3099 
3100 static uno::Any lcl_getSheetModule( const uno::Reference<table::XCellRange>& xCellRange, const ScDocument* pDok )
3101 {
3102  uno::Reference< sheet::XSheetCellRange > xSheetRange( xCellRange, uno::UNO_QUERY_THROW );
3103  uno::Reference< beans::XPropertySet > xProps( xSheetRange->getSpreadsheet(), uno::UNO_QUERY_THROW );
3104  OUString sCodeName;
3105  xProps->getPropertyValue("CodeName") >>= sCodeName;
3106  // #TODO #FIXME ideally we should 'throw' here if we don't get a valid parent, but... it is possible
3107  // to create a module ( and use 'Option VBASupport 1' ) for a calc document, in this scenario there
3108  // are *NO* special document module objects ( of course being able to switch between vba/non vba mode at
3109  // the document in the future could fix this, especially IF the switching of the vba mode takes care to
3110  // create the special document module objects if they don't exist.
3111  BasicManager* pBasMgr = pDok->GetDocumentShell()->GetBasicManager();
3112 
3113  uno::Reference< uno::XInterface > xIf;
3114  if ( pBasMgr && !pBasMgr->GetName().isEmpty() )
3115  {
3116  OUString sProj( "Standard" );
3117  if ( !pDok->GetDocumentShell()->GetBasicManager()->GetName().isEmpty() )
3118  {
3119  sProj = pDok->GetDocumentShell()->GetBasicManager()->GetName();
3120  }
3121  StarBASIC* pBasic = pDok->GetDocumentShell()->GetBasicManager()->GetLib( sProj );
3122  if ( pBasic )
3123  {
3124  SbModule* pMod = pBasic->FindModule( sCodeName );
3125  if ( pMod )
3126  {
3127  xIf = pMod->GetUnoModule();
3128  }
3129  }
3130  }
3131  return uno::makeAny( xIf );
3132 }
3133 
3134 static bool lcl_setVBARange( const ScRange& aRange, const ScDocument& rDok, SbxVariable* pPar )
3135 {
3136  bool bOk = false;
3137  try
3138  {
3139  uno::Reference< uno::XInterface > xVBARange;
3140  uno::Reference<table::XCellRange> xCellRange = ScCellRangeObj::CreateRangeFromDoc( rDok, aRange );
3141  uno::Sequence< uno::Any > aArgs(2);
3142  aArgs[0] = lcl_getSheetModule( xCellRange, &rDok );
3143  aArgs[1] <<= xCellRange;
3144  xVBARange = ooo::vba::createVBAUnoAPIServiceWithArgs( rDok.GetDocumentShell(), "ooo.vba.excel.Range", aArgs );
3145  if ( xVBARange.is() )
3146  {
3147  SbxObjectRef aObj = GetSbUnoObject( "A-Range", uno::Any( xVBARange ) );
3148  SetSbUnoObjectDfltPropName( aObj.get() );
3149  bOk = pPar->PutObject( aObj.get() );
3150  }
3151  }
3152  catch( uno::Exception& )
3153  {
3154  }
3155  return bOk;
3156 }
3157 
3158 static bool lcl_isNumericResult( double& fVal, const SbxVariable* pVar )
3159 {
3160  switch (pVar->GetType())
3161  {
3162  case SbxINTEGER:
3163  case SbxLONG:
3164  case SbxSINGLE:
3165  case SbxDOUBLE:
3166  case SbxCURRENCY:
3167  case SbxDATE:
3168  case SbxUSHORT:
3169  case SbxULONG:
3170  case SbxINT:
3171  case SbxUINT:
3172  case SbxSALINT64:
3173  case SbxSALUINT64:
3174  case SbxDECIMAL:
3175  fVal = pVar->GetDouble();
3176  return true;
3177  case SbxBOOL:
3178  fVal = (pVar->GetBool() ? 1.0 : 0.0);
3179  return true;
3180  default:
3181  ; // nothing
3182  }
3183  return false;
3184 }
3185 
3186 #endif
3187 
3188 void ScInterpreter::ScMacro()
3189 {
3190 
3191 #if !HAVE_FEATURE_SCRIPTING
3192  PushNoValue(); // without DocShell no CallBasic
3193  return;
3194 #else
3195  SbxBase::ResetError();
3196 
3197  sal_uInt8 nParamCount = GetByte();
3198  OUString aMacro( pCur->GetExternal() );
3199 
3200  SfxObjectShell* pDocSh = mrDoc.GetDocumentShell();
3201  if ( !pDocSh )
3202  {
3203  PushNoValue(); // without DocShell no CallBasic
3204  return;
3205  }
3206 
3207  // no security queue beforehand (just CheckMacroWarn), moved to CallBasic
3208 
3209  // If the Dok was loaded during a Basic-Calls,
3210  // is the Sbx-object created(?)
3211 // pDocSh->GetSbxObject();
3212 
3213  // search function with the name,
3214  // then assemble SfxObjectShell::CallBasic from aBasicStr, aMacroStr
3215 
3216  StarBASIC* pRoot;
3217 
3218  try
3219  {
3220  pRoot = pDocSh->GetBasic();
3221  }
3222  catch (...)
3223  {
3224  pRoot = nullptr;
3225  }
3226 
3227  SbxVariable* pVar = pRoot ? pRoot->Find(aMacro, SbxClassType::Method) : nullptr;
3228  if( !pVar || pVar->GetType() == SbxVOID )
3229  {
3230  PushError( FormulaError::NoMacro );
3231  return;
3232  }
3233  SbMethod* pMethod = dynamic_cast<SbMethod*>(pVar);
3234  if( !pMethod )
3235  {
3236  PushError( FormulaError::NoMacro );
3237  return;
3238  }
3239 
3240  bool bVolatileMacro = false;
3241 
3242  SbModule* pModule = pMethod->GetModule();
3243  bool bUseVBAObjects = pModule->IsVBACompat();
3244  SbxObject* pObject = pModule->GetParent();
3245  OSL_ENSURE(dynamic_cast<const StarBASIC *>(pObject) != nullptr, "No Basic found!");
3246  OUString aMacroStr = pObject->GetName() + "." + pModule->GetName() + "." + pMethod->GetName();
3247  OUString aBasicStr;
3248  if (pRoot && bUseVBAObjects)
3249  {
3250  // just here to make sure the VBA objects when we run the macro during ODF import
3251  pRoot->getVBAGlobals();
3252  }
3253  if (pObject->GetParent())
3254  {
3255  aBasicStr = pObject->GetParent()->GetName(); // document BASIC
3256  }
3257  else
3258  {
3259  aBasicStr = SfxGetpApp()->GetName(); // application BASIC
3260  }
3261  // assemble a parameter array
3262 
3263  SbxArrayRef refPar = new SbxArray;
3264  bool bOk = true;
3265  for( sal_uInt32 i = nParamCount; i && bOk ; i-- )
3266  {
3267  SbxVariable* pPar = refPar->Get(i);
3268  switch( GetStackType() )
3269  {
3270  case svDouble:
3271  pPar->PutDouble( GetDouble() );
3272  break;
3273  case svString:
3274  pPar->PutString( GetString().getString() );
3275  break;
3276  case svExternalSingleRef:
3277  {
3278  ScExternalRefCache::TokenRef pToken;
3279  PopExternalSingleRef(pToken);
3280  if (nGlobalError != FormulaError::NONE)
3281  bOk = false;
3282  else
3283  {
3284  if ( pToken->GetType() == svString )
3285  pPar->PutString( pToken->GetString().getString() );
3286  else if ( pToken->GetType() == svDouble )
3287  pPar->PutDouble( pToken->GetDouble() );
3288  else
3289  {
3290  SetError( FormulaError::IllegalArgument );
3291  bOk = false;
3292  }
3293  }
3294  }
3295  break;
3296  case svSingleRef:
3297  {
3298  ScAddress aAdr;
3299  PopSingleRef( aAdr );
3300  if ( bUseVBAObjects )
3301  {
3302  ScRange aRange( aAdr );
3303  bOk = lcl_setVBARange( aRange, mrDoc, pPar );
3304  }
3305  else
3306  {
3307  bOk = SetSbxVariable( pPar, aAdr );
3308  }
3309  }
3310  break;
3311  case svDoubleRef:
3312  {
3313  SCCOL nCol1;
3314  SCROW nRow1;
3315  SCTAB nTab1;
3316  SCCOL nCol2;
3317  SCROW nRow2;
3318  SCTAB nTab2;
3319  PopDoubleRef( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
3320  if( nTab1 != nTab2 )
3321  {
3322  SetError( FormulaError::IllegalParameter );
3323  bOk = false;
3324  }
3325  else
3326  {
3327  if ( bUseVBAObjects )
3328  {
3329  ScRange aRange( nCol1, nRow1, nTab1, nCol2, nRow2, nTab2 );
3330  bOk = lcl_setVBARange( aRange, mrDoc, pPar );
3331  }
3332  else
3333  {
3334  SbxDimArrayRef refArray = new SbxDimArray;
3335  refArray->AddDim(1, nRow2 - nRow1 + 1);
3336  refArray->AddDim(1, nCol2 - nCol1 + 1);
3337  ScAddress aAdr( nCol1, nRow1, nTab1 );
3338  for( SCROW nRow = nRow1; bOk && nRow <= nRow2; nRow++ )
3339  {
3340  aAdr.SetRow( nRow );
3341  sal_Int32 nIdx[ 2 ];
3342  nIdx[ 0 ] = nRow-nRow1+1;
3343  for( SCCOL nCol = nCol1; bOk && nCol <= nCol2; nCol++ )
3344  {
3345  aAdr.SetCol( nCol );
3346  nIdx[ 1 ] = nCol-nCol1+1;
3347  SbxVariable* p = refArray->Get(nIdx);
3348  bOk = SetSbxVariable( p, aAdr );
3349  }
3350  }
3351  pPar->PutObject( refArray.get() );
3352  }
3353  }
3354  }
3355  break;
3356  case svExternalDoubleRef:
3357  case svMatrix:
3358  {
3359  ScMatrixRef pMat = GetMatrix();
3360  SCSIZE nC, nR;
3361  if (pMat && nGlobalError == FormulaError::NONE)
3362  {
3363  pMat->GetDimensions(nC, nR);
3364  SbxDimArrayRef refArray = new SbxDimArray;
3365  refArray->AddDim(1, static_cast<sal_Int32>(nR));
3366  refArray->AddDim(1, static_cast<sal_Int32>(nC));
3367  for( SCSIZE nMatRow = 0; nMatRow < nR; nMatRow++ )
3368  {
3369  sal_Int32 nIdx[ 2 ];
3370  nIdx[ 0 ] = static_cast<sal_Int32>(nMatRow+1);
3371  for( SCSIZE nMatCol = 0; nMatCol < nC; nMatCol++ )
3372  {
3373  nIdx[ 1 ] = static_cast<sal_Int32>(nMatCol+1);
3374  SbxVariable* p = refArray->Get(nIdx);
3375  if (pMat->IsStringOrEmpty(nMatCol, nMatRow))
3376  {
3377  p->PutString( pMat->GetString(nMatCol, nMatRow).getString() );
3378  }
3379  else
3380  {
3381  p->PutDouble( pMat->GetDouble(nMatCol, nMatRow));
3382  }
3383  }
3384  }
3385  pPar->PutObject( refArray.get() );
3386  }
3387  else
3388  {
3389  SetError( FormulaError::IllegalParameter );
3390  }
3391  }
3392  break;
3393  default:
3394  SetError( FormulaError::IllegalParameter );
3395  bOk = false;
3396  }
3397  }
3398  if( bOk )
3399  {
3400  mrDoc.LockTable( aPos.Tab() );
3401  SbxVariableRef refRes = new SbxVariable;
3402  mrDoc.IncMacroInterpretLevel();
3403  ErrCode eRet = pDocSh->CallBasic( aMacroStr, aBasicStr, refPar.get(), refRes.get() );
3404  mrDoc.DecMacroInterpretLevel();
3405  mrDoc.UnlockTable( aPos.Tab() );
3406 
3407  ScMacroManager* pMacroMgr = mrDoc.GetMacroManager();
3408  if (pMacroMgr)
3409  {
3410  bVolatileMacro = pMacroMgr->GetUserFuncVolatile( pMethod->GetName() );
3411  pMacroMgr->AddDependentCell(pModule->GetName(), pMyFormulaCell);
3412  }
3413 
3414  double fVal;
3415  SbxDataType eResType = refRes->GetType();
3416  if( SbxBase::GetError() )
3417  {
3418  SetError( FormulaError::NoValue);
3419  }
3420  if ( eRet != ERRCODE_NONE )
3421  {
3422  PushNoValue();
3423  }
3424  else if (lcl_isNumericResult( fVal, refRes.get()))
3425  {
3426  switch (eResType)
3427  {
3428  case SbxDATE:
3429  nFuncFmtType = SvNumFormatType::DATE;
3430  break;
3431  case SbxBOOL:
3432  nFuncFmtType = SvNumFormatType::LOGICAL;
3433  break;
3434  // Do not add SbxCURRENCY, we don't know which currency.
3435  default:
3436  ; // nothing
3437  }
3438  PushDouble( fVal );
3439  }
3440  else if ( eResType & SbxARRAY )
3441  {
3442  SbxBase* pElemObj = refRes->GetObject();
3443  SbxDimArray* pDimArray = dynamic_cast<SbxDimArray*>(pElemObj);
3444  sal_Int32 nDim = pDimArray ? pDimArray->GetDims() : 0;
3445  if ( 1 <= nDim && nDim <= 2 )
3446  {
3447  sal_Int32 nCs, nCe, nRs;
3448  SCSIZE nC, nR;
3449  SCCOL nColIdx;
3450  SCROW nRowIdx;
3451  if ( nDim == 1 )
3452  { // array( cols ) one line, several columns
3453  pDimArray->GetDim(1, nCs, nCe);
3454  nC = static_cast<SCSIZE>(nCe - nCs + 1);
3455  nRs = 0;
3456  nR = 1;
3457  nColIdx = 0;
3458  nRowIdx = 1;
3459  }
3460  else
3461  { // array( rows, cols )
3462  sal_Int32 nRe;
3463  pDimArray->GetDim(1, nRs, nRe);
3464  nR = static_cast<SCSIZE>(nRe - nRs + 1);
3465  pDimArray->GetDim(2, nCs, nCe);
3466  nC = static_cast<SCSIZE>(nCe - nCs + 1);
3467  nColIdx = 1;
3468  nRowIdx = 0;
3469  }
3470  ScMatrixRef pMat = GetNewMat( nC, nR, /*bEmpty*/true);
3471  if ( pMat )
3472  {
3473  SbxVariable* pV;
3474  for ( SCSIZE j=0; j < nR; j++ )
3475  {
3476  sal_Int32 nIdx[ 2 ];
3477  // in one-dimensional array( cols ) nIdx[1]
3478  // from SbxDimArray::Get is ignored
3479  nIdx[ nRowIdx ] = nRs + static_cast<sal_Int32>(j);
3480  for ( SCSIZE i=0; i < nC; i++ )
3481  {
3482  nIdx[ nColIdx ] = nCs + static_cast<sal_Int32>(i);
3483  pV = pDimArray->Get(nIdx);
3484  if ( lcl_isNumericResult( fVal, pV) )
3485  {
3486  pMat->PutDouble( fVal, i, j );
3487  }
3488  else
3489  {
3490  pMat->PutString(mrStrPool.intern(pV->GetOUString()), i, j);
3491  }
3492  }
3493  }
3494  PushMatrix( pMat );
3495  }
3496  else
3497  {
3498  PushIllegalArgument();
3499  }
3500  }
3501  else
3502  {
3503  PushNoValue();
3504  }
3505  }
3506  else
3507  {
3508  PushString( refRes->GetOUString() );
3509  }
3510  }
3511 
3512  if (bVolatileMacro && meVolatileType == NOT_VOLATILE)
3513  meVolatileType = VOLATILE_MACRO;
3514 #endif
3515 }
3516 
3517 #if HAVE_FEATURE_SCRIPTING
3518 
3519 bool ScInterpreter::SetSbxVariable( SbxVariable* pVar, const ScAddress& rPos )
3520 {
3521  bool bOk = true;
3522  ScRefCellValue aCell(mrDoc, rPos);
3523  if (!aCell.isEmpty())
3524  {
3525  FormulaError nErr;
3526  double nVal;
3527  switch (aCell.meType)
3528  {
3529  case CELLTYPE_VALUE :
3530  nVal = GetValueCellValue(rPos, aCell.mfValue);
3531  pVar->PutDouble( nVal );
3532  break;
3533  case CELLTYPE_STRING :
3534  case CELLTYPE_EDIT :
3535  pVar->PutString(aCell.getString(&mrDoc));
3536  break;
3537  case CELLTYPE_FORMULA :
3538  nErr = aCell.mpFormula->GetErrCode();
3539  if( nErr == FormulaError::NONE )
3540  {
3541  if (aCell.mpFormula->IsValue())
3542  {
3543  nVal = aCell.mpFormula->GetValue();
3544  pVar->PutDouble( nVal );
3545  }
3546  else
3547  pVar->PutString(aCell.mpFormula->GetString().getString());
3548  }
3549  else
3550  {
3551  SetError( nErr );
3552  bOk = false;
3553  }
3554  break;
3555  default :
3556  pVar->PutEmpty();
3557  }
3558  }
3559  else
3560  pVar->PutEmpty();
3561 
3562  return bOk;
3563 }
3564 
3565 #endif
3566 
3567 void ScInterpreter::ScTableOp()
3568 {
3569  sal_uInt8 nParamCount = GetByte();
3570  if (nParamCount != 3 && nParamCount != 5)
3571  {
3572  PushIllegalParameter();
3573  return;
3574  }
3575  std::unique_ptr<ScInterpreterTableOpParams> pTableOp(new ScInterpreterTableOpParams);
3576  if (nParamCount == 5)
3577  {
3578  PopSingleRef( pTableOp->aNew2 );
3579  PopSingleRef( pTableOp->aOld2 );
3580  }
3581  PopSingleRef( pTableOp->aNew1 );
3582  PopSingleRef( pTableOp->aOld1 );
3583  PopSingleRef( pTableOp->aFormulaPos );
3584 
3585  pTableOp->bValid = true;
3586  mrDoc.m_TableOpList.push_back(pTableOp.get());
3587  mrDoc.IncInterpreterTableOpLevel();
3588 
3589  bool bReuseLastParams = (mrDoc.aLastTableOpParams == *pTableOp);
3590  if ( bReuseLastParams )
3591  {
3592  pTableOp->aNotifiedFormulaPos = mrDoc.aLastTableOpParams.aNotifiedFormulaPos;
3593  pTableOp->bRefresh = true;
3594  for ( const auto& rPos : pTableOp->aNotifiedFormulaPos )
3595  { // emulate broadcast and indirectly collect cell pointers
3596  ScRefCellValue aCell(mrDoc, rPos);
3597  if (aCell.meType == CELLTYPE_FORMULA)
3598  aCell.mpFormula->SetTableOpDirty();
3599  }
3600  }
3601  else
3602  { // broadcast and indirectly collect cell pointers and positions
3603  mrDoc.SetTableOpDirty( pTableOp->aOld1 );
3604  if ( nParamCount == 5 )
3605  mrDoc.SetTableOpDirty( pTableOp->aOld2 );
3606  }
3607  pTableOp->bCollectNotifications = false;
3608 
3609  ScRefCellValue aCell(mrDoc, pTableOp->aFormulaPos);
3610  if (aCell.meType == CELLTYPE_FORMULA)
3611  aCell.mpFormula->SetDirtyVar();
3612  if (aCell.hasNumeric())
3613  {
3614  PushDouble(GetCellValue(pTableOp->aFormulaPos, aCell));
3615  }
3616  else
3617  {
3618  svl::SharedString aCellString;
3619  GetCellString(aCellString, aCell);
3620  PushString( aCellString );
3621  }
3622 
3623  auto const itr =
3624  ::std::find(mrDoc.m_TableOpList.begin(), mrDoc.m_TableOpList.end(), pTableOp.get());
3625  if (itr != mrDoc.m_TableOpList.end())
3626  {
3627  mrDoc.m_TableOpList.erase(itr);
3628  }
3629 
3630  // set dirty again once more to be able to recalculate original
3631  for ( const auto& pCell : pTableOp->aNotifiedFormulaCells )
3632  {
3633  pCell->SetTableOpDirty();
3634  }
3635 
3636  // save these params for next incarnation
3637  if ( !bReuseLastParams )
3638  mrDoc.aLastTableOpParams = *pTableOp;
3639 
3640  if (aCell.meType == CELLTYPE_FORMULA)
3641  {
3642  aCell.mpFormula->SetDirtyVar();
3643  aCell.mpFormula->GetErrCode(); // recalculate original
3644  }
3645 
3646  // Reset all dirty flags so next incarnation does really collect all cell
3647  // pointers during notifications and not just non-dirty ones, which may
3648  // happen if a formula cell is used by more than one TableOp block.
3649  for ( const auto& pCell : pTableOp->aNotifiedFormulaCells )
3650  {
3651  pCell->ResetTableOpDirtyVar();
3652  }
3653  pTableOp.reset();
3654 
3655  mrDoc.DecInterpreterTableOpLevel();
3656 }
3657 
3658 void ScInterpreter::ScDBArea()
3659 {
3660  ScDBData* pDBData = mrDoc.GetDBCollection()->getNamedDBs().findByIndex(pCur->GetIndex());
3661  if (pDBData)
3662  {
3663  ScComplexRefData aRefData;
3664  aRefData.InitFlags();
3665  ScRange aRange;
3666  pDBData->GetArea(aRange);
3667  aRange.aEnd.SetTab(aRange.aStart.Tab());
3668  aRefData.SetRange(mrDoc.GetSheetLimits(), aRange, aPos);
3669  PushTempToken( new ScDoubleRefToken( mrDoc.GetSheetLimits(), aRefData ) );
3670  }
3671  else
3672  PushError( FormulaError::NoName);
3673 }
3674 
3675 void ScInterpreter::ScColRowNameAuto()
3676 {
3677  ScComplexRefData aRefData( *pCur->GetDoubleRef() );
3678  ScRange aAbs = aRefData.toAbs(mrDoc, aPos);
3679  if (!mrDoc.ValidRange(aAbs))
3680  {
3681  PushError( FormulaError::NoRef );
3682  return;
3683  }
3684 
3685  SCCOL nStartCol;
3686  SCROW nStartRow;
3687 
3688  // maybe remember limit by using defined ColRowNameRange
3689  SCCOL nCol2 = aAbs.aEnd.Col();
3690  SCROW nRow2 = aAbs.aEnd.Row();
3691  // DataArea of the first cell
3692  nStartCol = aAbs.aStart.Col();
3693  nStartRow = aAbs.aStart.Row();
3694  aAbs.aEnd = aAbs.aStart; // Shrink to the top-left cell.
3695 
3696  {
3697  // Expand to the data area. Only modify the end position.
3698  SCCOL nDACol1 = aAbs.aStart.Col(), nDACol2 = aAbs.aEnd.Col();
3699  SCROW nDARow1 = aAbs.aStart.Row(), nDARow2 = aAbs.aEnd.Row();
3700  mrDoc.GetDataArea(aAbs.aStart.Tab(), nDACol1, nDARow1, nDACol2, nDARow2, true, false);
3701  aAbs.aEnd.SetCol(nDACol2);
3702  aAbs.aEnd.SetRow(nDARow2);
3703  }
3704 
3705  // corresponds with ScCompiler::GetToken
3706  if ( aRefData.Ref1.IsColRel() )
3707  { // ColName
3708  aAbs.aEnd.SetCol(nStartCol);
3709  // maybe get previous limit by using defined ColRowNameRange
3710  if (aAbs.aEnd.Row() > nRow2)
3711  aAbs.aEnd.SetRow(nRow2);
3712  if ( aPos.Col() == nStartCol )
3713  {
3714  SCROW nMyRow = aPos.Row();
3715  if ( nStartRow <= nMyRow && nMyRow <= aAbs.aEnd.Row())
3716  { //Formula in the same column and within the range
3717  if ( nMyRow == nStartRow )
3718  { // take the rest under the name
3719  nStartRow++;
3720  if ( nStartRow > mrDoc.MaxRow() )
3721  nStartRow = mrDoc.MaxRow();
3722  aAbs.aStart.SetRow(nStartRow);
3723  }
3724  else
3725  { // below the name to the formula cell
3726  aAbs.aEnd.SetRow(nMyRow - 1);
3727  }
3728  }
3729  }
3730  }
3731  else
3732  { // RowName
3733  aAbs.aEnd.SetRow(nStartRow);
3734  // maybe get previous limit by using defined ColRowNameRange
3735  if (aAbs.aEnd.Col() > nCol2)
3736  aAbs.aEnd.SetCol(nCol2);
3737  if ( aPos.Row() == nStartRow )
3738  {
3739  SCCOL nMyCol = aPos.Col();
3740  if (nStartCol <= nMyCol && nMyCol <= aAbs.aEnd.Col())
3741  { //Formula in the same column and within the range
3742  if ( nMyCol == nStartCol )
3743  { // take the rest under the name
3744  nStartCol++;
3745  if ( nStartCol > mrDoc.MaxCol() )
3746  nStartCol = mrDoc.MaxCol();
3747  aAbs.aStart.SetCol(nStartCol);
3748  }
3749  else
3750  { // below the name to the formula cell
3751  aAbs.aEnd.SetCol(nMyCol - 1);
3752  }
3753  }
3754  }
3755  }
3756  aRefData.SetRange(mrDoc.GetSheetLimits(), aAbs, aPos);
3757  PushTempToken( new ScDoubleRefToken( mrDoc.GetSheetLimits(), aRefData ) );
3758 }
3759 
3760 // --- internals ------------------------------------------------------------
3761 
3762 void ScInterpreter::ScTTT()
3763 { // temporary test, testing functions etc.
3764  sal_uInt8 nParamCount = GetByte();
3765  // do something, count down nParamCount with Pops!
3766 
3767  // clean up Stack
3768  while ( nParamCount-- > 0)
3769  Pop();
3770  PushError(FormulaError::NoValue);
3771 }
3772 
3773 ScInterpreter::ScInterpreter( ScFormulaCell* pCell, ScDocument& rDoc, ScInterpreterContext& rContext,
3774  const ScAddress& rPos, ScTokenArray& r, bool bForGroupThreading )
3775  : aCode(r)
3776  , aPos(rPos)
3777  , pArr(&r)
3778  , mrContext(rContext)
3779  , mrDoc(rDoc)
3780  , mpLinkManager(rDoc.GetLinkManager())
3781  , mrStrPool(rDoc.GetSharedStringPool())
3782  , pJumpMatrix(nullptr)
3783  , pMyFormulaCell(pCell)
3784  , pFormatter(rContext.GetFormatTable())
3785  , pCur(nullptr)
3786  , nGlobalError(FormulaError::NONE)
3787  , sp(0)
3788  , maxsp(0)
3789  , nFuncFmtIndex(0)
3790  , nCurFmtIndex(0)
3791  , nRetFmtIndex(0)
3792  , nFuncFmtType(SvNumFormatType::ALL)
3793  , nCurFmtType(SvNumFormatType::ALL)
3794  , nRetFmtType(SvNumFormatType::ALL)
3795  , mnStringNoValueError(FormulaError::NoValue)
3796  , mnSubTotalFlags(SubtotalFlags::NONE)
3797  , cPar(0)
3798  , bCalcAsShown(rDoc.GetDocOptions().IsCalcAsShown())
3799  , meVolatileType(r.IsRecalcModeAlways() ? VOLATILE : NOT_VOLATILE)
3800 {
3801  MergeCalcConfig();
3802 
3803  if(pMyFormulaCell)
3804  {
3805  ScMatrixMode cMatFlag = pMyFormulaCell->GetMatrixFlag();
3806  bMatrixFormula = ( cMatFlag == ScMatrixMode::Formula );
3807  }
3808  else
3809  bMatrixFormula = false;
3810 
3811  // Lets not use the global stack while formula-group-threading.
3812  // as it complicates its life-cycle mgmt since for threading formula-groups,
3813  // ScInterpreter is preallocated (in main thread) for each worker thread.
3814  if (!bGlobalStackInUse && !bForGroupThreading)
3815  {
3816  bGlobalStackInUse = true;
3817  if (!pGlobalStack)
3818  pGlobalStack.reset(new ScTokenStack);
3819  pStackObj = pGlobalStack.get();
3820  }
3821  else
3822  {
3823  pStackObj = new ScTokenStack;
3824  }
3825  pStack = pStackObj->pPointer;
3826 }
3827 
3828 ScInterpreter::~ScInterpreter()
3829 {
3830  if ( pStackObj == pGlobalStack.get() )
3831  bGlobalStackInUse = false;
3832  else
3833  delete pStackObj;
3834 }
3835 
3836 void ScInterpreter::Init( ScFormulaCell* pCell, const ScAddress& rPos, ScTokenArray& rTokArray )
3837 {
3838  aCode.ReInit(rTokArray);
3839  aPos = rPos;
3840  pArr = &rTokArray;
3841  xResult = nullptr;
3842  pJumpMatrix = nullptr;
3843  pTokenMatrixMap.reset();
3844  pMyFormulaCell = pCell;
3845  pCur = nullptr;
3846  nGlobalError = FormulaError::NONE;
3847  sp = 0;
3848  maxsp = 0;
3849  nFuncFmtIndex = 0;
3850  nCurFmtIndex = 0;
3851  nRetFmtIndex = 0;
3852  nFuncFmtType = SvNumFormatType::ALL;
3853  nCurFmtType = SvNumFormatType::ALL;
3854  nRetFmtType = SvNumFormatType::ALL;
3855  mnStringNoValueError = FormulaError::NoValue;
3856  mnSubTotalFlags = SubtotalFlags::NONE;
3857  cPar = 0;
3858 }
3859 
3860 ScCalcConfig& ScInterpreter::GetOrCreateGlobalConfig()
3861 {
3862  if (!mpGlobalConfig)
3863  mpGlobalConfig = new ScCalcConfig();
3864  return *mpGlobalConfig;
3865 }
3866 
3867 void ScInterpreter::SetGlobalConfig(const ScCalcConfig& rConfig)
3868 {
3869  GetOrCreateGlobalConfig() = rConfig;
3870 }
3871 
3872 const ScCalcConfig& ScInterpreter::GetGlobalConfig()
3873 {
3874  return GetOrCreateGlobalConfig();
3875 }
3876 
3877 void ScInterpreter::MergeCalcConfig()
3878 {
3879  maCalcConfig = GetOrCreateGlobalConfig();
3880  maCalcConfig.MergeDocumentSpecific( mrDoc.GetCalcConfig());
3881 }
3882 
3883 void ScInterpreter::GlobalExit()
3884 {
3885  OSL_ENSURE(!bGlobalStackInUse, "who is still using the TokenStack?");
3886  pGlobalStack.reset();
3887 }
3888 
3889 namespace {
3890 
3891 double applyImplicitIntersection(const sc::RangeMatrix& rMat, const ScAddress& rPos)
3892 {
3893  if (rMat.mnRow1 <= rPos.Row() && rPos.Row() <= rMat.mnRow2 && rMat.mnCol1 == rMat.mnCol2)
3894  {
3895  SCROW nOffset = rPos.Row() - rMat.mnRow1;
3896  return rMat.mpMat->GetDouble(0, nOffset);
3897  }
3898 
3899  if (rMat.mnCol1 <= rPos.Col() && rPos.Col() <= rMat.mnCol2 && rMat.mnRow1 == rMat.mnRow2)
3900  {
3901  SCROW nOffset = rPos.Col() - rMat.mnCol1;
3902  return rMat.mpMat->GetDouble(nOffset, 0);
3903  }
3904 
3905  double fVal;
3906  rtl::math::setNan(&fVal);
3907  return fVal;
3908 }
3909 
3910 // Test for Functions that evaluate an error code and directly set nGlobalError to 0
3911 bool IsErrFunc(OpCode oc)
3912 {
3913  switch (oc)
3914  {
3915  case ocCount :
3916  case ocCount2 :
3917  case ocErrorType :
3918  case ocIsEmpty :
3919  case ocIsErr :
3920  case ocIsError :
3921  case ocIsFormula :
3922  case ocIsLogical :
3923  case ocIsNA :
3924  case ocIsNonString :
3925  case ocIsRef :
3926  case ocIsString :
3927  case ocIsValue :
3928  case ocN :
3929  case ocType :
3930  case ocIfError :
3931  case ocIfNA :
3932  case ocErrorType_ODF :
3933  case ocAggregate: // may ignore errors depending on option
3934  case ocIfs_MS:
3935  case ocSwitch_MS:
3936  return true;
3937  default:
3938  return false;
3939  }
3940 }
3941 
3942 } //namespace
3943 
3944 StackVar ScInterpreter::Interpret()
3945 {
3946  SvNumFormatType nRetTypeExpr = SvNumFormatType::UNDEFINED;
3947  sal_uInt32 nRetIndexExpr = 0;
3948  sal_uInt16 nErrorFunction = 0;
3949  sal_uInt16 nErrorFunctionCount = 0;
3950  std::vector<sal_uInt16> aErrorFunctionStack;
3951  sal_uInt16 nStackBase;
3952 
3953  nGlobalError = FormulaError::NONE;
3954  nStackBase = sp = maxsp = 0;
3955  nRetFmtType = SvNumFormatType::UNDEFINED;
3956  nFuncFmtType = SvNumFormatType::UNDEFINED;
3957  nFuncFmtIndex = nCurFmtIndex = nRetFmtIndex = 0;
3958  xResult = nullptr;
3959  pJumpMatrix = nullptr;
3960  mnSubTotalFlags = SubtotalFlags::NONE;
3961  ScTokenMatrixMap::const_iterator aTokenMatrixMapIter;
3962 
3963  // Once upon a time we used to have FP exceptions on, and there was a
3964  // Windows printer driver that kept switching off exceptions, so we had to
3965  // switch them back on again every time. Who knows if there isn't a driver
3966  // that keeps switching exceptions on, now that we run with exceptions off,
3967  // so reassure exceptions are really off.
3968  SAL_MATH_FPEXCEPTIONS_OFF();
3969 
3970  OpCode eOp = ocNone;
3971  aCode.Reset();
3972  for (;;)
3973  {
3974  pCur = aCode.Next();
3975  if (!pCur || (nGlobalError != FormulaError::NONE && nErrorFunction > nErrorFunctionCount) )
3976  break;
3977  eOp = pCur->GetOpCode();
3978  cPar = pCur->GetByte();
3979  if ( eOp == ocPush )
3980  {
3981  // RPN code push without error
3982  PushWithoutError( *pCur );
3983  nCurFmtType = SvNumFormatType::UNDEFINED;
3984  }
3985  else if (pTokenMatrixMap &&
3986  !FormulaCompiler::IsOpCodeJumpCommand( eOp ) &&
3987  ((aTokenMatrixMapIter = pTokenMatrixMap->find( pCur)) !=
3988  pTokenMatrixMap->end()) &&
3989  (*aTokenMatrixMapIter).second->GetType() != svJumpMatrix)
3990  {
3991  // Path already calculated, reuse result.
3992  nStackBase = sp - pCur->GetParamCount();
3993  if ( nStackBase > sp )
3994  nStackBase = sp; // underflow?!?
3995  sp = nStackBase;
3996  PushTokenRef( (*aTokenMatrixMapIter).second);
3997  }
3998  else
3999  {
4000  // previous expression determines the current number format
4001  nCurFmtType = nRetTypeExpr;
4002  nCurFmtIndex = nRetIndexExpr;
4003  // default function's format, others are set if needed
4004  nFuncFmtType = SvNumFormatType::NUMBER;
4005  nFuncFmtIndex = 0;
4006 
4007  if (FormulaCompiler::IsOpCodeJumpCommand( eOp ))
4008  nStackBase = sp; // don't mess around with the jumps
4009  else
4010  {
4011  // Convert parameters to matrix if in array/matrix formula and
4012  // parameters of function indicate doing so. Create JumpMatrix
4013  // if necessary.
4014  if ( MatrixParameterConversion() )
4015  {
4016  eOp = ocNone; // JumpMatrix created
4017  nStackBase = sp;
4018  }
4019  else if (sp >= pCur->GetParamCount())
4020  nStackBase = sp - pCur->GetParamCount();
4021  else
4022  nStackBase = sp; // underflow?!?
4023  }
4024 
4025  switch( eOp )
4026  {
4027  case ocSep:
4028  case ocClose: // pushed by the compiler
4029  case ocMissing : ScMissing(); break;
4030  case ocMacro : ScMacro(); break;
4031  case ocDBArea : ScDBArea(); break;
4032  case ocColRowNameAuto : ScColRowNameAuto(); break;
4033  case ocIf : ScIfJump(); break;
4034  case ocIfError : ScIfError( false ); break;
4035  case ocIfNA : ScIfError( true ); break;
4036  case ocChoose : ScChooseJump(); break;
4037  case ocAdd : ScAdd(); break;
4038  case ocSub : ScSub(); break;
4039  case ocMul : ScMul(); break;
4040  case ocDiv : ScDiv(); break;
4041  case ocAmpersand : ScAmpersand(); break;
4042  case ocPow : ScPow(); break;
4043  case ocEqual : ScEqual(); break;
4044  case ocNotEqual : ScNotEqual(); break;
4045  case ocLess : ScLess(); break;
4046  case ocGreater : ScGreater(); break;
4047  case ocLessEqual : ScLessEqual(); break;
4048  case ocGreaterEqual : ScGreaterEqual(); break;
4049  case ocAnd : ScAnd(); break;
4050  case ocOr : ScOr(); break;
4051  case ocXor : ScXor(); break;
4052  case ocIntersect : ScIntersect(); break;
4053  case ocRange : ScRangeFunc(); break;
4054  case ocUnion : ScUnionFunc(); break;
4055  case ocNot : ScNot(); break;
4056  case ocNegSub :
4057  case ocNeg : ScNeg(); break;
4058  case ocPercentSign : ScPercentSign(); break;
4059  case ocPi : ScPi(); break;
4060  case ocRandom : ScRandom(); break;
4061  case ocRandomNV : ScRandom(); break;
4062  case ocRandbetweenNV : ScRandbetween(); break;
4063  case ocTrue : ScTrue(); break;
4064  case ocFalse : ScFalse(); break;
4065  case ocGetActDate : ScGetActDate(); break;
4066  case ocGetActTime : ScGetActTime(); break;
4067  case ocNotAvail : PushError( FormulaError::NotAvailable); break;
4068  case ocDeg : ScDeg(); break;
4069  case ocRad : ScRad(); break;
4070  case ocSin : ScSin(); break;
4071  case ocCos : ScCos(); break;
4072  case ocTan : ScTan(); break;
4073  case ocCot : ScCot(); break;
4074  case ocArcSin : ScArcSin(); break;
4075  case ocArcCos : ScArcCos(); break;
4076  case ocArcTan : ScArcTan(); break;
4077  case ocArcCot : ScArcCot(); break;
4078  case ocSinHyp : ScSinHyp(); break;
4079  case ocCosHyp : ScCosHyp(); break;
4080  case ocTanHyp : ScTanHyp(); break;
4081  case ocCotHyp : ScCotHyp(); break;
4082  case ocArcSinHyp : ScArcSinHyp(); break;
4083  case ocArcCosHyp : ScArcCosHyp(); break;
4084  case ocArcTanHyp : ScArcTanHyp(); break;
4085  case ocArcCotHyp : ScArcCotHyp(); break;
4086  case ocCosecant : ScCosecant(); break;
4087  case ocSecant : ScSecant(); break;
4088  case ocCosecantHyp : ScCosecantHyp(); break;
4089  case ocSecantHyp : ScSecantHyp(); break;
4090  case ocExp : ScExp(); break;
4091  case ocLn : ScLn(); break;
4092  case ocLog10 : ScLog10(); break;
4093  case ocSqrt : ScSqrt(); break;
4094  case ocFact : ScFact(); break;
4095  case ocGetYear : ScGetYear(); break;
4096  case ocGetMonth : ScGetMonth(); break;
4097  case ocGetDay : ScGetDay(); break;
4098  case ocGetDayOfWeek : ScGetDayOfWeek(); break;
4099  case ocWeek : ScGetWeekOfYear(); break;
4100  case ocIsoWeeknum : ScGetIsoWeekOfYear(); break;
4101  case ocWeeknumOOo : ScWeeknumOOo(); break;
4102  case ocEasterSunday : ScEasterSunday(); break;
4103  case ocNetWorkdays : ScNetWorkdays( false); break;
4104  case ocNetWorkdays_MS : ScNetWorkdays( true ); break;
4105  case ocWorkday_MS : ScWorkday_MS(); break;
4106  case ocGetHour : ScGetHour(); break;
4107  case ocGetMin : ScGetMin(); break;
4108  case ocGetSec : ScGetSec(); break;
4109  case ocPlusMinus : ScPlusMinus(); break;
4110  case ocAbs : ScAbs(); break;
4111  case ocInt : ScInt(); break;
4112  case ocEven : ScEven(); break;
4113  case ocOdd : ScOdd(); break;
4114  case ocPhi : ScPhi(); break;
4115  case ocGauss : ScGauss(); break;
4116  case ocStdNormDist : ScStdNormDist(); break;
4117  case ocStdNormDist_MS : ScStdNormDist_MS(); break;
4118  case ocFisher : ScFisher(); break;
4119  case ocFisherInv : ScFisherInv(); break;
4120  case ocIsEmpty : ScIsEmpty(); break;
4121  case ocIsString : ScIsString(); break;
4122  case ocIsNonString : ScIsNonString(); break;
4123  case ocIsLogical : ScIsLogical(); break;
4124  case ocType : ScType(); break;
4125  case ocCell : ScCell(); break;
4126  case ocIsRef : ScIsRef(); break;
4127  case ocIsValue : ScIsValue(); break;
4128  case ocIsFormula : ScIsFormula(); break;
4129  case ocFormula : ScFormula(); break;
4130  case ocIsNA : ScIsNV(); break;
4131  case ocIsErr : ScIsErr(); break;
4132  case ocIsError : ScIsError(); break;
4133  case ocIsEven : ScIsEven(); break;
4134  case ocIsOdd : ScIsOdd(); break;
4135  case ocN : ScN(); break;
4136  case ocGetDateValue : ScGetDateValue(); break;
4137  case ocGetTimeValue : ScGetTimeValue(); break;
4138  case ocCode : ScCode(); break;
4139  case ocTrim : ScTrim(); break;
4140  case ocUpper : ScUpper(); break;
4141  case ocProper : ScProper(); break;
4142  case ocLower : ScLower(); break;
4143  case ocLen : ScLen(); break;
4144  case ocT : ScT(); break;
4145  case ocClean : ScClean(); break;
4146  case ocValue : ScValue(); break;
4147  case ocNumberValue : ScNumberValue(); break;
4148  case ocChar : ScChar(); break;
4149  case ocArcTan2 : ScArcTan2(); break;
4150  case ocMod : ScMod(); break;
4151  case ocPower : ScPower(); break;
4152  case ocRound : ScRound(); break;
4153  case ocRoundSig : ScRoundSignificant(); break;
4154  case ocRoundUp : ScRoundUp(); break;
4155  case ocTrunc :
4156  case ocRoundDown : ScRoundDown(); break;
4157  case ocCeil : ScCeil( true ); break;
4158  case ocCeil_MS : ScCeil_MS(); break;
4159  case ocCeil_Precise :
4160  case ocCeil_ISO : ScCeil_Precise(); break;
4161  case ocCeil_Math : ScCeil( false ); break;
4162  case ocFloor : ScFloor( true ); break;
4163  case ocFloor_MS : ScFloor_MS(); break;
4164  case ocFloor_Precise : ScFloor_Precise(); break;
4165  case ocFloor_Math : ScFloor( false ); break;
4166  case ocSumProduct : ScSumProduct(); break;
4167  case ocSumSQ : ScSumSQ(); break;
4168  case ocSumX2MY2 : ScSumX2MY2(); break;
4169  case ocSumX2DY2 : ScSumX2DY2(); break;
4170  case ocSumXMY2 : ScSumXMY2(); break;
4171  case ocRawSubtract : ScRawSubtract(); break;
4172  case ocLog : ScLog(); break;
4173  case ocGCD : ScGCD(); break;
4174  case ocLCM : ScLCM(); break;
4175  case ocGetDate : ScGetDate(); break;
4176  case ocGetTime : ScGetTime(); break;
4177  case ocGetDiffDate : ScGetDiffDate(); break;
4178  case ocGetDiffDate360 : ScGetDiffDate360(); break;
4179  case ocGetDateDif : ScGetDateDif(); break;
4180  case ocMin : ScMin() ; break;
4181  case ocMinA : ScMin( true ); break;
4182  case ocMax : ScMax(); break;
4183  case ocMaxA : ScMax( true ); break;
4184  case ocSum : ScSum(); break;
4185  case ocProduct : ScProduct(); break;
4186  case ocNPV : ScNPV(); break;
4187  case ocIRR : ScIRR(); break;
4188  case ocMIRR : ScMIRR(); break;
4189  case ocISPMT : ScISPMT(); break;
4190  case ocAverage : ScAverage() ; break;
4191  case ocAverageA : ScAverage( true ); break;
4192  case ocCount : ScCount(); break;
4193  case ocCount2 : ScCount2(); break;
4194  case ocVar :
4195  case ocVarS : ScVar(); break;
4196  case ocVarA : ScVar( true ); break;
4197  case ocVarP :
4198  case ocVarP_MS : ScVarP(); break;
4199  case ocVarPA : ScVarP( true ); break;
4200  case ocStDev :
4201  case ocStDevS : ScStDev(); break;
4202  case ocStDevA : ScStDev( true ); break;
4203  case ocStDevP :
4204  case ocStDevP_MS : ScStDevP(); break;
4205  case ocStDevPA : ScStDevP( true ); break;
4206  case ocPV : ScPV(); break;
4207  case ocSYD : ScSYD(); break;
4208  case ocDDB : ScDDB(); break;
4209  case ocDB : ScDB(); break;
4210  case ocVBD : ScVDB(); break;
4211  case ocPDuration : ScPDuration(); break;
4212  case ocSLN : ScSLN(); break;
4213  case ocPMT : ScPMT(); break;
4214  case ocColumns : ScColumns(); break;
4215  case ocRows : ScRows(); break;
4216  case ocSheets : ScSheets(); break;
4217  case ocColumn : ScColumn(); break;
4218  case ocRow : ScRow(); break;
4219  case ocSheet : ScSheet(); break;
4220  case ocRRI : ScRRI(); break;
4221  case ocFV : ScFV(); break;
4222  case ocNper : ScNper(); break;
4223  case ocRate : ScRate(); break;
4224  case ocFilterXML : ScFilterXML(); break;
4225  case ocWebservice : ScWebservice(); break;
4226  case ocEncodeURL : ScEncodeURL(); break;
4227  case ocColor : ScColor(); break;
4228  case ocErf_MS : ScErf(); break;
4229  case ocErfc_MS : ScErfc(); break;
4230  case ocIpmt : ScIpmt(); break;
4231  case ocPpmt : ScPpmt(); break;
4232  case ocCumIpmt : ScCumIpmt(); break;
4233  case ocCumPrinc : ScCumPrinc(); break;
4234  case ocEffect : ScEffect(); break;
4235  case ocNominal : ScNominal(); break;
4236  case ocSubTotal : ScSubTotal(); break;
4237  case ocAggregate : ScAggregate(); break;
4238  case ocDBSum : ScDBSum(); break;
4239  case ocDBCount : ScDBCount(); break;
4240  case ocDBCount2 : ScDBCount2(); break;
4241  case ocDBAverage : ScDBAverage(); break;
4242  case ocDBGet : ScDBGet(); break;
4243  case ocDBMax : ScDBMax(); break;
4244  case ocDBMin : ScDBMin(); break;
4245  case ocDBProduct : ScDBProduct(); break;
4246  case ocDBStdDev : ScDBStdDev(); break;
4247  case ocDBStdDevP : ScDBStdDevP(); break;
4248  case ocDBVar : ScDBVar(); break;
4249  case ocDBVarP : ScDBVarP(); break;
4250  case ocIndirect : ScIndirect(); break;
4251  case ocAddress : ScAddressFunc(); break;
4252  case ocMatch : ScMatch(); break;
4253  case ocCountEmptyCells : ScCountEmptyCells(); break;
4254  case ocCountIf : ScCountIf(); break;
4255  case ocSumIf : ScSumIf(); break;
4256  case ocAverageIf : ScAverageIf(); break;
4257  case ocSumIfs : ScSumIfs(); break;
4258  case ocAverageIfs : ScAverageIfs(); break;
4259  case ocCountIfs : ScCountIfs(); break;
4260  case ocLookup : ScLookup(); break;
4261  case ocVLookup : ScVLookup(); break;
4262  case ocHLookup : ScHLookup(); break;
4263  case ocIndex : ScIndex(); break;
4264  case ocMultiArea : ScMultiArea(); break;
4265  case ocOffset : ScOffset(); break;
4266  case ocAreas : ScAreas(); break;
4267  case ocCurrency : ScCurrency(); break;
4268  case ocReplace : ScReplace(); break;
4269  case ocFixed : ScFixed(); break;
4270  case ocFind : ScFind(); break;
4271  case ocExact : ScExact(); break;
4272  case ocLeft : ScLeft(); break;
4273  case ocRight : ScRight(); break;
4274  case ocSearch : ScSearch(); break;
4275  case ocMid : ScMid(); break;
4276  case ocText : ScText(); break;
4277  case ocSubstitute : ScSubstitute(); break;
4278  case ocRegex : ScRegex(); break;
4279  case ocRept : ScRept(); break;
4280  case ocConcat : ScConcat(); break;
4281  case ocConcat_MS : ScConcat_MS(); break;
4282  case ocTextJoin_MS : ScTextJoin_MS(); break;
4283  case ocIfs_MS : ScIfs_MS(); break;
4284  case ocSwitch_MS : ScSwitch_MS(); break;
4285  case ocMinIfs_MS : ScMinIfs_MS(); break;
4286  case ocMaxIfs_MS : ScMaxIfs_MS(); break;
4287  case ocMatValue : ScMatValue(); break;
4288  case ocMatrixUnit : ScEMat(); break;
4289  case ocMatDet : ScMatDet(); break;
4290  case ocMatInv : ScMatInv(); break;
4291  case ocMatMult : ScMatMult(); break;
4292  case ocMatTrans : ScMatTrans(); break;
4293  case ocMatRef : ScMatRef(); break;
4294  case ocB : ScB(); break;
4295  case ocNormDist : ScNormDist( 3 ); break;
4296  case ocNormDist_MS : ScNormDist( 4 ); break;
4297  case ocExpDist :
4298  case ocExpDist_MS : ScExpDist(); break;
4299  case ocBinomDist :
4300  case ocBinomDist_MS : ScBinomDist(); break;
4301  case ocPoissonDist : ScPoissonDist( true ); break;
4302  case ocPoissonDist_MS : ScPoissonDist( false ); break;
4303  case ocCombin : ScCombin(); break;
4304  case ocCombinA : ScCombinA(); break;
4305  case ocPermut : ScPermut(); break;
4306  case ocPermutationA : ScPermutationA(); break;
4307  case ocHypGeomDist : ScHypGeomDist( 4 ); break;
4308  case ocHypGeomDist_MS : ScHypGeomDist( 5 ); break;
4309  case ocLogNormDist : ScLogNormDist( 1 ); break;
4310  case ocLogNormDist_MS : ScLogNormDist( 4 ); break;
4311  case ocTDist : ScTDist(); break;
4312  case ocTDist_MS : ScTDist_MS(); break;
4313  case ocTDist_RT : ScTDist_T( 1 ); break;
4314  case ocTDist_2T : ScTDist_T( 2 ); break;
4315  case ocFDist :
4316  case ocFDist_RT : ScFDist(); break;
4317  case ocFDist_LT : ScFDist_LT(); break;
4318  case ocChiDist : ScChiDist( true ); break;
4319  case ocChiDist_MS : ScChiDist( false ); break;
4320  case ocChiSqDist : ScChiSqDist(); break;
4321  case ocChiSqDist_MS : ScChiSqDist_MS(); break;
4322  case ocStandard : ScStandard(); break;
4323  case ocAveDev : ScAveDev(); break;
4324  case ocDevSq : ScDevSq(); break;
4325  case ocKurt : ScKurt(); break;
4326  case ocSkew : ScSkew(); break;
4327  case ocSkewp : ScSkewp(); break;
4328  case ocModalValue : ScModalValue(); break;
4329  case ocModalValue_MS : ScModalValue_MS( true ); break;
4330  case ocModalValue_Multi : ScModalValue_MS( false ); break;
4331  case ocMedian : ScMedian(); break;
4332  case ocGeoMean : ScGeoMean(); break;
4333  case ocHarMean : ScHarMean(); break;
4334  case ocWeibull :
4335  case ocWeibull_MS : ScWeibull(); break;
4336  case ocBinomInv :
4337  case ocCritBinom : ScCritBinom(); break;
4338  case ocNegBinomVert : ScNegBinomDist(); break;
4339  case ocNegBinomDist_MS : ScNegBinomDist_MS(); break;
4340  case ocNoName : ScNoName(); break;
4341  case ocBad : ScBadName(); break;
4342  case ocZTest :
4343  case ocZTest_MS : ScZTest(); break;
4344  case ocTTest :
4345  case ocTTest_MS : ScTTest(); break;
4346  case ocFTest :
4347  case ocFTest_MS : ScFTest(); break;
4348  case ocRank :
4349  case ocRank_Eq : ScRank( false ); break;
4350  case ocRank_Avg : ScRank( true ); break;
4351  case ocPercentile :
4352  case ocPercentile_Inc : ScPercentile( true ); break;
4353  case ocPercentile_Exc : ScPercentile( false ); break;
4354  case ocPercentrank :
4355  case ocPercentrank_Inc : ScPercentrank( true ); break;
4356  case ocPercentrank_Exc : ScPercentrank( false ); break;
4357  case ocLarge : ScLarge(); break;
4358  case ocSmall : ScSmall(); break;
4359  case ocFrequency : ScFrequency(); break;
4360  case ocQuartile :
4361  case ocQuartile_Inc : ScQuartile( true ); break;
4362  case ocQuartile_Exc : ScQuartile( false ); break;
4363  case ocNormInv :
4364  case ocNormInv_MS : ScNormInv(); break;
4365  case ocSNormInv :
4366  case ocSNormInv_MS : ScSNormInv(); break;
4367  case ocConfidence :
4368  case ocConfidence_N : ScConfidence(); break;
4369  case ocConfidence_T : ScConfidenceT(); break;
4370  case ocTrimMean : ScTrimMean(); break;
4371  case ocProb : ScProbability(); break;
4372  case ocCorrel : ScCorrel(); break;
4373  case ocCovar :
4374  case ocCovarianceP : ScCovarianceP(); break;
4375  case ocCovarianceS : ScCovarianceS(); break;
4376  case ocPearson : ScPearson(); break;
4377  case ocRSQ : ScRSQ(); break;
4378  case ocSTEYX : ScSTEYX(); break;
4379  case ocSlope : ScSlope(); break;
4380  case ocIntercept : ScIntercept(); break;
4381  case ocTrend : ScTrend(); break;
4382  case ocGrowth : ScGrowth(); break;
4383  case ocLinest : ScLinest(); break;
4384  case ocLogest : ScLogest(); break;
4385  case ocForecast_LIN :
4386  case ocForecast : ScForecast(); break;
4387  case ocForecast_ETS_ADD : ScForecast_Ets( etsAdd ); break;
4388  case ocForecast_ETS_SEA : ScForecast_Ets( etsSeason ); break;
4389  case ocForecast_ETS_MUL : ScForecast_Ets( etsMult ); break;
4390  case ocForecast_ETS_PIA : ScForecast_Ets( etsPIAdd ); break;
4391  case ocForecast_ETS_PIM : ScForecast_Ets( etsPIMult ); break;
4392  case ocForecast_ETS_STA : ScForecast_Ets( etsStatAdd ); break;
4393  case ocForecast_ETS_STM : ScForecast_Ets( etsStatMult ); break;
4394  case ocGammaLn :
4395  case ocGammaLn_MS : ScLogGamma(); break;
4396  case ocGamma : ScGamma(); break;
4397  case ocGammaDist : ScGammaDist( true ); break;
4398  case ocGammaDist_MS : ScGammaDist( false ); break;
4399  case ocGammaInv :
4400  case ocGammaInv_MS : ScGammaInv(); break;
4401  case ocChiTest :
4402  case ocChiTest_MS : ScChiTest(); break;
4403  case ocChiInv :
4404  case ocChiInv_MS : ScChiInv(); break;
4405  case ocChiSqInv :
4406  case ocChiSqInv_MS : ScChiSqInv(); break;
4407  case ocTInv :
4408  case ocTInv_2T : ScTInv( 2 ); break;
4409  case ocTInv_MS : ScTInv( 4 ); break;
4410  case ocFInv :
4411  case ocFInv_RT : ScFInv(); break;
4412  case ocFInv_LT : ScFInv_LT(); break;
4413  case ocLogInv :
4414  case ocLogInv_MS : ScLogNormInv(); break;
4415  case ocBetaDist : ScBetaDist(); break;
4416  case ocBetaDist_MS : ScBetaDist_MS(); break;
4417  case ocBetaInv :
4418  case ocBetaInv_MS : ScBetaInv(); break;
4419  case ocFourier : ScFourier(); break;
4420  case ocExternal : ScExternal(); break;
4421  case ocTableOp : ScTableOp(); break;
4422  case ocStop : break;
4423  case ocErrorType : ScErrorType(); break;
4424  case ocErrorType_ODF : ScErrorType_ODF(); break;
4425  case ocCurrent : ScCurrent(); break;
4426  case ocStyle : ScStyle(); break;
4427  case ocDde : ScDde(); break;
4428  case ocBase : ScBase(); break;
4429  case ocDecimal : ScDecimal(); break;
4430  case ocConvertOOo : ScConvertOOo(); break;
4431  case ocEuroConvert : ScEuroConvert(); break;
4432  case ocRoman : ScRoman(); break;
4433  case ocArabic : ScArabic(); break;
4434  case ocInfo : ScInfo(); break;
4435  case ocHyperLink : ScHyperLink(); break;
4436  case ocBahtText : ScBahtText(); break;
4437  case ocGetPivotData : ScGetPivotData(); break;
4438  case ocJis : ScJis(); break;
4439  case ocAsc : ScAsc(); break;
4440  case ocLenB : ScLenB(); break;
4441  case ocRightB : ScRightB(); break;
4442  case ocLeftB : ScLeftB(); break;
4443  case ocMidB : ScMidB(); break;
4444  case ocReplaceB : ScReplaceB(); break;
4445  case ocFindB : ScFindB(); break;
4446  case ocSearchB : ScSearchB(); break;
4447  case ocUnicode : ScUnicode(); break;
4448  case ocUnichar : ScUnichar(); break;
4449  case ocBitAnd : ScBitAnd(); break;
4450  case ocBitOr : ScBitOr(); break;
4451  case ocBitXor : ScBitXor(); break;
4452  case ocBitRshift : ScBitRshift(); break;
4453  case ocBitLshift : ScBitLshift(); break;
4454  case ocTTT : ScTTT(); break;
4455  case ocDebugVar : ScDebugVar(); break;
4456  case ocNone : nFuncFmtType = SvNumFormatType::UNDEFINED; break;
4457  default : PushError( FormulaError::UnknownOpCode); break;
4458  }
4459 
4460  // If the function pushed a subroutine as result, continue with
4461  // execution of the subroutine.
4462  if (sp > nStackBase && pStack[sp-1]->GetOpCode() == ocCall)
4463  {
4464  Pop(); continue;
4465  }
4466 
4467  if (FormulaCompiler::IsOpCodeVolatile(eOp))
4468  meVolatileType = VOLATILE;
4469 
4470  // Remember result matrix in case it could be reused.
4471  if (pTokenMatrixMap && sp && GetStackType() == svMatrix)
4472  pTokenMatrixMap->emplace(pCur, pStack[sp-1]);
4473 
4474  // outer function determines format of an expression
4475  if ( nFuncFmtType != SvNumFormatType::UNDEFINED )
4476  {
4477  nRetTypeExpr = nFuncFmtType;
4478  // Inherit the format index for currency, date or time formats.
4479  switch (nFuncFmtType)
4480  {
4481  case SvNumFormatType::CURRENCY:
4482  case SvNumFormatType::DATE:
4483  case SvNumFormatType::TIME:
4484  case SvNumFormatType::DATETIME:
4485  case SvNumFormatType::DURATION:
4486  nRetIndexExpr = nFuncFmtIndex;
4487  break;
4488  default:
4489  nRetIndexExpr = 0;
4490  }
4491  }
4492  }
4493 
4494  // Need a clean stack environment for the JumpMatrix to work.
4495  if (nGlobalError != FormulaError::NONE && eOp != ocPush && sp > nStackBase + 1)
4496  {
4497  // Not all functions pop all parameters in case an error is
4498  // generated. Clean up stack. Assumes that every function pushes a
4499  // result, may be arbitrary in case of error.
4500  FormulaConstTokenRef xLocalResult = pStack[ sp - 1 ];
4501  while (sp > nStackBase)
4502  Pop();
4503  PushTokenRef( xLocalResult );
4504  }
4505 
4506  bool bGotResult;
4507  do
4508  {
4509  bGotResult = false;
4510  sal_uInt8 nLevel = 0;
4511  if ( GetStackType( ++nLevel ) == svJumpMatrix )
4512  ; // nothing
4513  else if ( GetStackType( ++nLevel ) == svJumpMatrix )
4514  ; // nothing
4515  else
4516  nLevel = 0;
4517  if ( nLevel == 1 || (nLevel == 2 && aCode.IsEndOfPath()) )
4518  {
4519  if (nLevel == 1)
4520  aErrorFunctionStack.push_back( nErrorFunction);
4521  bGotResult = JumpMatrix( nLevel );
4522  if (aErrorFunctionStack.empty())
4523  assert(!"ScInterpreter::Interpret - aErrorFunctionStack empty in JumpMatrix context");
4524  else
4525  {
4526  nErrorFunction = aErrorFunctionStack.back();
4527  if (bGotResult)
4528  aErrorFunctionStack.pop_back();
4529  }
4530  }
4531  else
4532  pJumpMatrix = nullptr;
4533  } while ( bGotResult );
4534 
4535  if( IsErrFunc(eOp) )
4536  ++nErrorFunction;
4537 
4538  if ( nGlobalError != FormulaError::NONE )
4539  {
4540  if ( !nErrorFunctionCount )
4541  { // count of errorcode functions in formula
4542  FormulaTokenArrayPlainIterator aIter(*pArr);
4543  for ( FormulaToken* t = aIter.FirstRPN(); t; t = aIter.NextRPN() )
4544  {
4545  if ( IsErrFunc(t->GetOpCode()) )
4546  ++nErrorFunctionCount;
4547  }
4548  }
4549  if ( nErrorFunction >= nErrorFunctionCount )
4550  ++nErrorFunction; // that's it, error => terminate
4551  }
4552  }
4553 
4554  // End: obtain result
4555 
4556  bool bForcedResultType;
4557  switch (eOp)
4558  {
4559  case ocGetDateValue:
4560  case ocGetTimeValue:
4561  // Force final result of DATEVALUE and TIMEVALUE to number type,
4562  // which so far was date or time for calculations.
4563  nRetTypeExpr = nFuncFmtType = SvNumFormatType::NUMBER;
4564  nRetIndexExpr = nFuncFmtIndex = 0;
4565  bForcedResultType = true;
4566  break;
4567  default:
4568  bForcedResultType = false;
4569  }
4570 
4571  if (sp == 1)
4572  {
4573  pCur = pStack[ sp-1 ];
4574  if( pCur->GetOpCode() == ocPush )
4575  {
4576  // An svRefList can be resolved if it a) contains just one
4577  // reference, or b) in array context contains an array of single
4578  // cell references.
4579  if (pCur->GetType() == svRefList)
4580  {
4581  PopRefListPushMatrixOrRef();
4582  pCur = pStack[ sp-1 ];
4583  }
4584  switch( pCur->GetType() )
4585  {
4586  case svEmptyCell:
4587  ; // nothing
4588  break;
4589  case svError:
4590  nGlobalError = pCur->GetError();
4591  break;
4592  case svDouble :
4593  {
4594  // If typed, pop token to obtain type information and
4595  // push a plain untyped double so the result token to
4596  // be transferred to the formula cell result does not
4597  // unnecessarily duplicate the information.
4598  if (pCur->GetDoubleType() != 0)
4599  {
4600  double fVal = PopDouble();
4601  if (!bForcedResultType)
4602  {
4603  if (nCurFmtType != nFuncFmtType)
4604  nRetIndexExpr = 0; // carry format index only for matching type
4605  nRetTypeExpr = nFuncFmtType = nCurFmtType;
4606  }
4607  if (nRetTypeExpr == SvNumFormatType::DURATION)
4608  {
4609  // Round the duration in case a wall clock time
4610  // display format is used instead of a duration
4611  // format. To micro seconds which then catches
4612  // the converted hh:mm:ss.9999997 cases.
4613  if (fVal != 0.0)
4614  {
4615  fVal *= 86400.0;
4616  fVal = rtl::math::round( fVal, 6);
4617  fVal /= 86400.0;
4618  }
4619  }
4620  PushTempToken( CreateFormulaDoubleToken( fVal));
4621  }
4622  if ( nFuncFmtType == SvNumFormatType::UNDEFINED )
4623  {
4624  nRetTypeExpr = SvNumFormatType::NUMBER;
4625  nRetIndexExpr = 0;
4626  }
4627  }
4628  break;
4629  case svString :
4630  nRetTypeExpr = SvNumFormatType::TEXT;
4631  nRetIndexExpr = 0;
4632  break;
4633  case svSingleRef :
4634  {
4635  ScAddress aAdr;
4636  PopSingleRef( aAdr );
4637  if( nGlobalError == FormulaError::NONE)
4638  PushCellResultToken( false, aAdr, &nRetTypeExpr, &nRetIndexExpr, true);
4639  }
4640  break;
4641  case svRefList :
4642  PopError(); // maybe #REF! takes precedence over #VALUE!
4643  PushError( FormulaError::NoValue);
4644  break;
4645  case svDoubleRef :
4646  {
4647  if ( bMatrixFormula )
4648  { // create matrix for {=A1:A5}
4649  PopDoubleRefPushMatrix();
4650  ScMatrixRef xMat = PopMatrix();
4651  QueryMatrixType(xMat, nRetTypeExpr, nRetIndexExpr);
4652  }
4653  else
4654  {
4655  ScRange aRange;
4656  PopDoubleRef( aRange );
4657  ScAddress aAdr;
4658  if ( nGlobalError == FormulaError::NONE && DoubleRefToPosSingleRef( aRange, aAdr))
4659  PushCellResultToken( false, aAdr, &nRetTypeExpr, &nRetIndexExpr, true);
4660  }
4661  }
4662  break;
4663  case svExternalDoubleRef:
4664  {
4665  ScMatrixRef xMat;
4666  PopExternalDoubleRef(xMat);
4667  QueryMatrixType(xMat, nRetTypeExpr, nRetIndexExpr);
4668  }
4669  break;
4670  case svMatrix :
4671  {
4672  sc::RangeMatrix aMat = PopRangeMatrix();
4673  if (aMat.isRangeValid())
4674  {
4675  // This matrix represents a range reference. Apply implicit intersection.
4676  double fVal = applyImplicitIntersection(aMat, aPos);
4677  if (std::isnan(fVal))
4678  PushNoValue();
4679  else
4680  PushInt(fVal);
4681  }
4682  else
4683  // This is a normal matrix.
4684  QueryMatrixType(aMat.mpMat, nRetTypeExpr, nRetIndexExpr);
4685  }
4686  break;
4687  case svExternalSingleRef:
4688  {
4689  FormulaTokenRef xToken;
4690  ScExternalRefCache::CellFormat aFmt;
4691  PopExternalSingleRef(xToken, &aFmt);
4692  if (nGlobalError != FormulaError::NONE)
4693  break;
4694 
4695  PushTokenRef(xToken);
4696 
4697  if (aFmt.mbIsSet)
4698  {
4699  nFuncFmtType = aFmt.mnType;
4700  nFuncFmtIndex = aFmt.mnIndex;
4701  }
4702  }
4703  break;
4704  default :
4705  SetError( FormulaError::UnknownStackVariable);
4706  }
4707  }
4708  else
4709  SetError( FormulaError::UnknownStackVariable);
4710  }
4711  else if (sp > 1)
4712  SetError( FormulaError::OperatorExpected);
4713  else
4714  SetError( FormulaError::NoCode);
4715 
4716  if (bForcedResultType || nRetTypeExpr != SvNumFormatType::UNDEFINED)
4717  {
4718  nRetFmtType = nRetTypeExpr;
4719  nRetFmtIndex = nRetIndexExpr;
4720  }
4721  else if( nFuncFmtType != SvNumFormatType::UNDEFINED )
4722  {
4723  nRetFmtType = nFuncFmtType;
4724  nRetFmtIndex = nFuncFmtIndex;
4725  }
4726  else
4727  nRetFmtType = SvNumFormatType::NUMBER;
4728 
4729  if (nGlobalError != FormulaError::NONE && GetStackType() != svError )
4730  PushError( nGlobalError);
4731 
4732  // THE final result.
4733  xResult = PopToken();
4734  if (!xResult)
4735  xResult = new FormulaErrorToken( FormulaError::UnknownStackVariable);
4736 
4737  // release tokens in expression stack
4738  const FormulaToken** p = pStack;
4739  while( maxsp-- )
4740  (*p++)->DecRef();
4741 
4742  StackVar eType = xResult->GetType();
4743  if (eType == svMatrix)
4744  // Results are immutable in case they would be reused as input for new
4745  // interpreters.
4746  xResult->GetMatrix()->SetImmutable();
4747  return eType;
4748 }
4749 
4750 void ScInterpreter::AssertFormulaMatrix()
4751 {
4752  bMatrixFormula = true;
4753 }
4754 
4755 const svl::SharedString & ScInterpreter::GetStringResult() const
4756 {
4757  return xResult->GetString();
4758 }
4759 
4760 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
svl::SharedString::getString
OUString getString() const
ScRange::aStart
ScAddress aStart
Definition: address.hxx:499
ScRefCellValue::getString
OUString getString(const ScDocument *pDoc) const
Retrieve string value.
Definition: cellvalue.cxx:660
SetError
int SetError()
ScInterpreter::Interpret
formula::StackVar Interpret()
Definition: interpr4.cxx:3944
ScRefCellValue::isEmpty
bool isEmpty() const
Definition: cellvalue.cxx:670
ScInterpreter::GetCellValueOrZero
double GetCellValueOrZero(const ScAddress &, ScRefCellValue &rCell)
Definition: interpr4.cxx:185
ScInterpreter::bGlobalStackInUse
static thread_local bool bGlobalStackInUse
Definition: interpre.hxx:191
ScGlobal::ConvertStringToValue
static double ConvertStringToValue(const OUString &rStr, const ScCalcConfig &rConfig, FormulaError &rError, FormulaError nStringNoValueError, SvNumberFormatter *pFormatter, SvNumFormatType &rCurFmtType)
Convert string content to numeric value.
Definition: global2.cxx:355
ScRange::aEnd
ScAddress aEnd
Definition: address.hxx:500
svl::SharedString::getEmptyString
static const SharedString & getEmptyString()
ScRefCellValue
This is very similar to ScCellValue, except that it references the original value instead of copying ...
Definition: cellvalue.hxx:103
ScInterpreter::GetCellValue
double GetCellValue(const ScAddress &, ScRefCellValue &rCell)
Definition: interpr4.cxx:175
ScInterpreter::GetCellNumberFormat
sal_uInt32 GetCellNumberFormat(const ScAddress &rPos, ScRefCellValue &rCell)
Definition: interpr4.cxx:122
SAL_MAX_UINT16
#define SAL_MAX_UINT16
ScFormulaCell::GetValue
double GetValue()
Definition: formulacell.cxx:2792
ScFormulaCell::GetErrCode
FormulaError GetErrCode()
Definition: formulacell.cxx:2972
ScRefCellValue::mpFormula
ScFormulaCell * mpFormula
Definition: cellvalue.hxx:110
eType
DocumentType eType
ScInterpreter::ConvertStringToValue
double ConvertStringToValue(const OUString &)
Definition: interpr4.cxx:160
i
int i
ScInterpreter::IsTableOpInRange
bool IsTableOpInRange(const ScRange &)
Definition: interpr4.cxx:104
SCCOL
sal_Int16 SCCOL
Definition: types.hxx:21
ScInterpreter::GetCellErrCode
static FormulaError GetCellErrCode(const ScRefCellValue &rCell)
Definition: interpr4.cxx:155
SvNumFormatType
SvNumFormatType
ScInterpreter::GetCellString
void GetCellString(svl::SharedString &rStr, ScRefCellValue &rCell)
Definition: interpr4.cxx:242
ScRange::In
bool In(const ScAddress &) const
is Address& in Range?
Definition: address.hxx:732
ScInterpreter::ReplaceCell
void ReplaceCell(ScAddress &)
Definition: interpr4.cxx:85
ScInterpreter::pGlobalStack
static thread_local std::unique_ptr< ScTokenStack > pGlobalStack
Definition: interpre.hxx:190
ScInterpreter::GetValueCellValue
double GetValueCellValue(const ScAddress &, double fOrig)
Only ValueCell, formula cells already store the result rounded.
Definition: interpr4.cxx:145
mrContext
const NodeContext & mrContext
ScFormulaCell::GetString
const svl::SharedString & GetString()
Definition: formulacell.cxx:2798
FormulaError
FormulaError
ScRefCellValue::meType
CellType meType
Definition: cellvalue.hxx:105
SCROW
sal_Int32 SCROW
Definition: types.hxx:17
sal_uInt8
unsigned char sal_uInt8
ScInterpreter::CreateDoubleArr
bool CreateDoubleArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8 *pCellArr)
Definition: interpr4.cxx:277
CellType
CellType
Definition: global.hxx:280
aStr
aStr
SCTAB
sal_Int16 SCTAB
Definition: types.hxx:22
Generated on Thu Apr 15 2021 20:34:24 for LibreOffice Module sc (master) by   doxygen 1.8.10