formula/source/core/api/token.cxx

   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
  21 #include <algorithm>
  22
  23 #include <string.h>
  24 #include <limits.h>
  25 #include <osl/diagnose.h>
  26 #include <sal/log.hxx>
  27
  28 #include <com/sun/star/sheet/FormulaToken.hpp>
  29 #include <formula/errorcodes.hxx>
  30 #include <formula/token.hxx>
  31 #include <formula/tokenarray.hxx>
  32 #include <formula/FormulaCompiler.hxx>
  33 #include <formula/compiler.hxx>
  34 #include <svl/sharedstringpool.hxx>
  35 #include <memory>
  36 #include <utility>
  37
  38 namespace formula
  39 {
  40     using namespace com::sun::star;
  41
  42
  43 // --- helpers --------------------------------------------------------------
  44
  45 static bool lcl_IsReference( OpCode eOp, StackVar eType )
  46 {
  47     return
  48         (eOp == ocPush && (eType == svSingleRef || eType == svDoubleRef))
  49         || (eOp == ocColRowNameAuto && eType == svDoubleRef)
  50         || (eOp == ocColRowName && eType == svSingleRef)
  51         || (eOp == ocMatRef && eType == svSingleRef)
  52         ;
  53 }
  54
  55 // --- class FormulaToken --------------------------------------------------------
  56
  57 FormulaToken::FormulaToken( StackVar eTypeP, OpCode e ) :
  58     eOp(e), eType( eTypeP ), eRefCntPolicy(RefCntPolicy::ThreadSafe), mnRefCnt(0)
  59 {
  60 }
  61
  62 FormulaToken::FormulaToken( const FormulaToken& r ) :
  63     eOp(r.eOp), eType( r.eType ), eRefCntPolicy(RefCntPolicy::ThreadSafe), mnRefCnt(0)
  64 {
  65 }
  66
  67 FormulaToken::~FormulaToken()
  68 {
  69 }
  70
  71 bool FormulaToken::IsFunction() const
  72 {
  73     return (eOp != ocPush && eOp != ocBad && eOp != ocColRowName &&
  74             eOp != ocColRowNameAuto && eOp != ocName && eOp != ocDBArea &&
  75             eOp != ocTableRef &&
  76            (GetByte() != 0                                                  // x parameters
  77         || (SC_OPCODE_START_NO_PAR <= eOp && eOp < SC_OPCODE_STOP_NO_PAR)   // no parameter
  78         || FormulaCompiler::IsOpCodeJumpCommand( eOp )                      // @ jump commands
  79         || (SC_OPCODE_START_1_PAR <= eOp && eOp < SC_OPCODE_STOP_1_PAR)     // one parameter
  80         || (SC_OPCODE_START_2_PAR <= eOp && eOp < SC_OPCODE_STOP_2_PAR)     // x parameters (cByte==0 in
  81                                                                             // FuncAutoPilot)
  82         || eOp == ocMacro || eOp == ocExternal                  // macros, AddIns
  83         || eOp == ocAnd || eOp == ocOr                          // former binary, now x parameters
  84         || (eOp >= ocInternalBegin && eOp <= ocInternalEnd)     // internal
  85         ));
  86 }
  87
  88
  89 sal_uInt8 FormulaToken::GetParamCount() const
  90 {
  91     if ( eOp < SC_OPCODE_STOP_DIV && eOp != ocExternal && eOp != ocMacro &&
  92          !FormulaCompiler::IsOpCodeJumpCommand( eOp ) &&
  93          eOp != ocPercentSign )
  94         return 0;       // parameters and specials
  95                         // ocIf... jump commands not for FAP, have cByte then
  96 //2do: bool parameter whether FAP or not?
  97     else if (GetByte())
  98         return GetByte();   // all functions, also ocExternal and ocMacro
  99     else if (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP && eOp != ocAnd && eOp != ocOr)
 100         return 2;           // binary operators, compiler checked; OR and AND legacy but are functions
 101     else if ((SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP) || eOp == ocPercentSign)
 102         return 1;           // unary operators, compiler checked
 103     else if (SC_OPCODE_START_NO_PAR <= eOp && eOp < SC_OPCODE_STOP_NO_PAR)
 104         return 0;           // no parameter
 105     else if (FormulaCompiler::IsOpCodeJumpCommand( eOp ))
 106         return 1;           // only the condition counts as parameter
 107     else
 108         return 0;           // all the rest, no Parameter, or
 109                             // if so then it should be in cByte
 110 }
 111
 112 bool FormulaToken::IsExternalRef() const
 113 {
 114     bool bRet = false;
 115     switch (eType)
 116     {
 117         case svExternalSingleRef:
 118         case svExternalDoubleRef:
 119         case svExternalName:
 120             bRet = true;
 121             break;
 122         default:
 123             bRet = false;
 124             break;
 125     }
 126     return bRet;
 127 }
 128
 129 bool FormulaToken::IsRef() const
 130 {
 131     switch (eType)
 132     {
 133         case svSingleRef:
 134         case svDoubleRef:
 135         case svExternalSingleRef:
 136         case svExternalDoubleRef:
 137             return true;
 138         default:
 139             if (eOp == ocTableRef)
 140                 return true;
 141     }
 142
 143     return false;
 144 }
 145
 146 bool FormulaToken::IsInForceArray() const
 147 {
 148     ParamClass eParam = GetInForceArray();
 149     return eParam == ParamClass::ForceArray || eParam == ParamClass::ReferenceOrForceArray
 150         || eParam == ParamClass::ReferenceOrRefArray || eParam == ParamClass::ForceArrayReturn;
 151 }
 152
 153 bool FormulaToken::operator==( const FormulaToken& rToken ) const
 154 {
 155     // don't compare reference count!
 156     return  eType == rToken.eType && GetOpCode() == rToken.GetOpCode();
 157 }
 158
 159
 160 // --- virtual dummy methods -------------------------------------------------
 161
 162 sal_uInt8 FormulaToken::GetByte() const
 163 {
 164     // ok to be called for any derived class
 165     return 0;
 166 }
 167
 168 void FormulaToken::SetByte( sal_uInt8 )
 169 {
 170     assert( !"virtual dummy called" );
 171 }
 172
 173 ParamClass FormulaToken::GetInForceArray() const
 174 {
 175     // ok to be called for any derived class
 176     return (eOp == ocPush && eType == svMatrix) ? ParamClass::ForceArrayReturn : ParamClass::Unknown;
 177 }
 178
 179 void FormulaToken::SetInForceArray( ParamClass )
 180 {
 181     assert( !"virtual dummy called" );
 182 }
 183
 184 double FormulaToken::GetDouble() const
 185 {
 186     // This Get is worth an assert.
 187     assert( !"virtual dummy called" );
 188     return 0.0;
 189 }
 190
 191 void FormulaToken::SetDouble(double)
 192 {
 193     // This Get is worth an assert.
 194     assert( !"virtual dummy called" );
 195 }
 196
 197 sal_Int16 FormulaToken::GetDoubleType() const
 198 {
 199     SAL_WARN( "formula.core", "FormulaToken::GetDoubleType: virtual dummy called" );
 200     return 0;
 201 }
 202
 203 void FormulaToken::SetDoubleType( sal_Int16 )
 204 {
 205     assert( !"virtual dummy called" );
 206 }
 207
 208 const svl::SharedString INVALID_STRING;
 209
 210 const svl::SharedString & FormulaToken::GetString() const
 211 {
 212     SAL_WARN( "formula.core", "FormulaToken::GetString: virtual dummy called" );
 213     return INVALID_STRING; // invalid string
 214 }
 215
 216 void FormulaToken::SetString( const svl::SharedString& )
 217 {
 218     assert( !"virtual dummy called" );
 219 }
 220
 221 sal_uInt16 FormulaToken::GetIndex() const
 222 {
 223     SAL_WARN( "formula.core", "FormulaToken::GetIndex: virtual dummy called" );
 224     return 0;
 225 }
 226
 227 void FormulaToken::SetIndex( sal_uInt16 )
 228 {
 229     assert( !"virtual dummy called" );
 230 }
 231
 232 sal_Int16 FormulaToken::GetSheet() const
 233 {
 234     SAL_WARN( "formula.core", "FormulaToken::GetSheet: virtual dummy called" );
 235     return -1;
 236 }
 237
 238 void FormulaToken::SetSheet( sal_Int16 )
 239 {
 240     assert( !"virtual dummy called" );
 241 }
 242
 243 sal_Unicode FormulaToken::GetChar() const
 244 {
 245     // This Get is worth an assert.
 246     assert( !"virtual dummy called" );
 247     return 0;
 248 }
 249
 250 short* FormulaToken::GetJump() const
 251 {
 252     SAL_WARN( "formula.core", "FormulaToken::GetJump: virtual dummy called" );
 253     return nullptr;
 254 }
 255
 256
 257 const OUString& FormulaToken::GetExternal() const
 258 {
 259     SAL_WARN( "formula.core", "FormulaToken::GetExternal: virtual dummy called" );
 260     static  OUString              aDummyString;
 261     return aDummyString;
 262 }
 263
 264 FormulaToken* FormulaToken::GetFAPOrigToken() const
 265 {
 266     SAL_WARN( "formula.core", "FormulaToken::GetFAPOrigToken: virtual dummy called" );
 267     return nullptr;
 268 }
 269
 270 FormulaError FormulaToken::GetError() const
 271 {
 272     SAL_WARN( "formula.core", "FormulaToken::GetError: virtual dummy called" );
 273     return FormulaError::NONE;
 274 }
 275
 276 void FormulaToken::SetError( FormulaError )
 277 {
 278     assert( !"virtual dummy called" );
 279 }
 280
 281 const ScSingleRefData* FormulaToken::GetSingleRef() const
 282 {
 283     OSL_FAIL( "FormulaToken::GetSingleRef: virtual dummy called" );
 284     return nullptr;
 285 }
 286
 287 ScSingleRefData* FormulaToken::GetSingleRef()
 288 {
 289     OSL_FAIL( "FormulaToken::GetSingleRef: virtual dummy called" );
 290     return nullptr;
 291 }
 292
 293 const ScComplexRefData* FormulaToken::GetDoubleRef() const
 294 {
 295     OSL_FAIL( "FormulaToken::GetDoubleRef: virtual dummy called" );
 296     return nullptr;
 297 }
 298
 299 ScComplexRefData* FormulaToken::GetDoubleRef()
 300 {
 301     OSL_FAIL( "FormulaToken::GetDoubleRef: virtual dummy called" );
 302     return nullptr;
 303 }
 304
 305 const ScSingleRefData* FormulaToken::GetSingleRef2() const
 306 {
 307     OSL_FAIL( "FormulaToken::GetSingleRef2: virtual dummy called" );
 308     return nullptr;
 309 }
 310
 311 ScSingleRefData* FormulaToken::GetSingleRef2()
 312 {
 313     OSL_FAIL( "FormulaToken::GetSingleRef2: virtual dummy called" );
 314     return nullptr;
 315 }
 316
 317 const ScMatrix* FormulaToken::GetMatrix() const
 318 {
 319     OSL_FAIL( "FormulaToken::GetMatrix: virtual dummy called" );
 320     return nullptr;
 321 }
 322
 323 ScMatrix* FormulaToken::GetMatrix()
 324 {
 325     OSL_FAIL( "FormulaToken::GetMatrix: virtual dummy called" );
 326     return nullptr;
 327 }
 328
 329 ScJumpMatrix* FormulaToken::GetJumpMatrix() const
 330 {
 331     OSL_FAIL( "FormulaToken::GetJumpMatrix: virtual dummy called" );
 332     return nullptr;
 333 }
 334 const std::vector<ScComplexRefData>* FormulaToken::GetRefList() const
 335 {
 336     OSL_FAIL( "FormulaToken::GetRefList: virtual dummy called" );
 337     return nullptr;
 338 }
 339
 340 std::vector<ScComplexRefData>* FormulaToken::GetRefList()
 341 {
 342     OSL_FAIL( "FormulaToken::GetRefList: virtual dummy called" );
 343     return nullptr;
 344 }
 345
 346 bool FormulaToken::TextEqual( const FormulaToken& rToken ) const
 347 {
 348     return *this == rToken;
 349 }
 350
 351 // real implementations of virtual functions
 352
 353
 354 sal_uInt8   FormulaSpaceToken::GetByte() const  { return nByte; }
 355 sal_Unicode FormulaSpaceToken::GetChar() const  { return cChar; }
 356 bool FormulaSpaceToken::operator==( const FormulaToken& r ) const
 357 {
 358     return FormulaToken::operator==( r ) && nByte == r.GetByte() &&
 359         cChar == r.GetChar();
 360 }
 361
 362
 363 sal_uInt8   FormulaByteToken::GetByte() const           { return nByte; }
 364 void        FormulaByteToken::SetByte( sal_uInt8 n )    { nByte = n; }
 365 ParamClass  FormulaByteToken::GetInForceArray() const    { return eInForceArray; }
 366 void        FormulaByteToken::SetInForceArray( ParamClass c ) { eInForceArray = c; }
 367 bool FormulaByteToken::operator==( const FormulaToken& r ) const
 368 {
 369     return FormulaToken::operator==( r ) && nByte == r.GetByte() &&
 370         eInForceArray == r.GetInForceArray();
 371 }
 372
 373
 374 FormulaToken* FormulaFAPToken::GetFAPOrigToken() const  { return pOrigToken.get(); }
 375 bool FormulaFAPToken::operator==( const FormulaToken& r ) const
 376 {
 377     return FormulaByteToken::operator==( r ) && pOrigToken == r.GetFAPOrigToken();
 378 }
 379
 380
 381 short*      FormulaJumpToken::GetJump() const                   { return pJump.get(); }
 382 ParamClass  FormulaJumpToken::GetInForceArray() const           { return eInForceArray; }
 383 void        FormulaJumpToken::SetInForceArray( ParamClass c )   { eInForceArray = c; }
 384 bool FormulaJumpToken::operator==( const FormulaToken& r ) const
 385 {
 386     return FormulaToken::operator==( r ) && pJump[0] == r.GetJump()[0] &&
 387         memcmp( pJump.get()+1, r.GetJump()+1, pJump[0] * sizeof(short) ) == 0 &&
 388         eInForceArray == r.GetInForceArray();
 389 }
 390 FormulaJumpToken::~FormulaJumpToken()
 391 {
 392 }
 393
 394
 395 bool FormulaTokenArray::AddFormulaToken(
 396     const sheet::FormulaToken& rToken, svl::SharedStringPool& rSPool, ExternalReferenceHelper* /*pExtRef*/)
 397 {
 398     bool bError = false;
 399     const OpCode eOpCode = static_cast<OpCode>(rToken.OpCode);      //! assuming equal values for the moment
 400
 401     const uno::TypeClass eClass = rToken.Data.getValueTypeClass();
 402     switch ( eClass )
 403     {
 404         case uno::TypeClass_VOID:
 405             // empty data -> use AddOpCode (does some special cases)
 406             AddOpCode( eOpCode );
 407             break;
 408         case uno::TypeClass_DOUBLE:
 409             // double is only used for "push"
 410             if ( eOpCode == ocPush )
 411                 AddDouble( rToken.Data.get<double>() );
 412             else
 413                 bError = true;
 414             break;
 415         case uno::TypeClass_LONG:
 416             {
 417                 // long is svIndex, used for name / database area, or "byte" for spaces
 418                 sal_Int32 nValue = rToken.Data.get<sal_Int32>();
 419                 if ( eOpCode == ocDBArea )
 420                     Add( new formula::FormulaIndexToken( eOpCode, static_cast<sal_uInt16>(nValue) ) );
 421                 else if ( eOpCode == ocSpaces )
 422                     Add( new formula::FormulaByteToken( ocSpaces, static_cast<sal_uInt8>(nValue) ) );
 423                 else
 424                     bError = true;
 425             }
 426             break;
 427         case uno::TypeClass_STRING:
 428             {
 429                 OUString aStrVal( rToken.Data.get<OUString>() );
 430                 if ( eOpCode == ocPush )
 431                     AddString(rSPool.intern(aStrVal));
 432                 else if ( eOpCode == ocBad )
 433                     AddBad( aStrVal );
 434                 else if ( eOpCode == ocStringXML )
 435                     AddStringXML( aStrVal );
 436                 else if ( eOpCode == ocStringName )
 437                     AddStringName( aStrVal );
 438                 else if ( eOpCode == ocExternal || eOpCode == ocMacro )
 439                     Add( new formula::FormulaExternalToken( eOpCode, aStrVal ) );
 440                 else if ( eOpCode == ocWhitespace )
 441                 {
 442                     // Simply ignore empty string.
 443                     // Convention is one character repeated.
 444                     if (!aStrVal.isEmpty())
 445                         Add( new formula::FormulaSpaceToken( static_cast<sal_uInt8>(aStrVal.getLength()), aStrVal[0]));
 446                 }
 447                 else
 448                     bError = true;      // unexpected string: don't know what to do with it
 449             }
 450             break;
 451         default:
 452             bError = true;
 453     } // switch ( eClass )
 454     return bError;
 455 }
 456
 457 bool FormulaTokenArray::Fill(
 458     const uno::Sequence<sheet::FormulaToken>& rSequence,
 459     svl::SharedStringPool& rSPool, ExternalReferenceHelper* pExtRef )
 460 {
 461     bool bError = false;
 462     const sal_Int32 nCount = rSequence.getLength();
 463     for (sal_Int32 nPos=0; nPos<nCount; nPos++)
 464     {
 465         bool bOneError = AddFormulaToken(rSequence[nPos], rSPool, pExtRef);
 466         if (bOneError)
 467         {
 468             AddOpCode( ocErrName);  // add something that indicates an error
 469             bError = true;
 470         }
 471     }
 472     return bError;
 473 }
 474
 475 void FormulaTokenArray::DelRPN()
 476 {
 477     if( nRPN )
 478     {
 479         FormulaToken** p = pRPN;
 480         for( sal_uInt16 i = 0; i < nRPN; i++ )
 481         {
 482             (*p++)->DecRef();
 483         }
 484         delete [] pRPN;
 485     }
 486     pRPN = nullptr;
 487     nRPN = 0;
 488 }
 489
 490 FormulaToken* FormulaTokenArray::FirstToken() const
 491 {
 492     if (!pCode || nLen == 0)
 493         return nullptr;
 494     return pCode[0];
 495 }
 496
 497 FormulaToken* FormulaTokenArray::PeekPrev( sal_uInt16 & nIdx ) const
 498 {
 499     if (0 < nIdx && nIdx <= nLen)
 500         return pCode[--nIdx];
 501     return nullptr;
 502 }
 503
 504 FormulaToken* FormulaTokenArray::FirstRPNToken() const
 505 {
 506     if (!pRPN || nRPN == 0)
 507         return nullptr;
 508     return pRPN[0];
 509 }
 510
 511 FormulaToken* FormulaTokenArray::LastRPNToken() const
 512 {
 513     if (!pRPN || nRPN == 0)
 514         return nullptr;
 515     return pRPN[nRPN - 1];
 516 }
 517
 518 bool FormulaTokenArray::HasReferences() const
 519 {
 520     for (auto i: Tokens())
 521     {
 522         if (i->IsRef())
 523             return true;
 524     }
 525
 526     for (auto i: RPNTokens())
 527     {
 528         if (i->IsRef())
 529             return true;
 530     }
 531
 532     return false;
 533 }
 534
 535 bool FormulaTokenArray::HasExternalRef() const
 536 {
 537     for (auto i: Tokens())
 538     {
 539         if (i->IsExternalRef())
 540             return true;
 541     }
 542     return false;
 543 }
 544
 545 bool FormulaTokenArray::HasOpCode( OpCode eOp ) const
 546 {
 547     for (auto i: Tokens())
 548     {
 549         if (i->GetOpCode() == eOp)
 550             return true;
 551     }
 552     return false;
 553 }
 554
 555 bool FormulaTokenArray::HasOpCodeRPN( OpCode eOp ) const
 556 {
 557     for (auto i: RPNTokens())
 558     {
 559         if (i->GetOpCode() == eOp)
 560             return true;
 561     }
 562     return false;
 563 }
 564
 565 bool FormulaTokenArray::HasNameOrColRowName() const
 566 {
 567     for (auto i: Tokens())
 568     {
 569         if (i->GetType() == svIndex || i->GetOpCode() == ocColRowName )
 570             return true;
 571     }
 572     return false;
 573 }
 574
 575 bool FormulaTokenArray::HasOpCodes(const unordered_opcode_set& rOpCodes) const
 576 {
 577     for (auto i: Tokens())
 578     {
 579         if (rOpCodes.count(i->GetOpCode()) > 0)
 580             return true;
 581     }
 582
 583     return false;
 584 }
 585
 586 FormulaTokenArray::FormulaTokenArray() :
 587     pRPN(nullptr),
 588     nLen(0),
 589     nRPN(0),
 590     nError(FormulaError::NONE),
 591     nMode(ScRecalcMode::NORMAL),
 592     bHyperLink(false),
 593     mbFromRangeName(false),
 594     mbShareable(true),
 595     mbFinalized(false)
 596 {
 597 }
 598
 599 FormulaTokenArray::FormulaTokenArray( const FormulaTokenArray& rArr )
 600 {
 601     Assign( rArr );
 602 }
 603
 604 FormulaTokenArray::FormulaTokenArray( FormulaTokenArray&& rArr )
 605 {
 606     Move( std::move(rArr) );
 607 }
 608
 609 FormulaTokenArray::~FormulaTokenArray()
 610 {
 611     FormulaTokenArray::Clear();
 612 }
 613
 614 void FormulaTokenArray::Finalize()
 615 {
 616     if( nLen && !mbFinalized )
 617     {
 618         // Add() overallocates, so reallocate to the minimum needed size.
 619         std::unique_ptr<FormulaToken*[]> newCode(new FormulaToken*[ nLen ]);
 620         std::copy(&pCode[0], &pCode[nLen], newCode.get());
 621         pCode = std::move( newCode );
 622         mbFinalized = true;
 623     }
 624 }
 625
 626 void FormulaTokenArray::Assign( const FormulaTokenArray& r )
 627 {
 628     nLen   = r.nLen;
 629     nRPN   = r.nRPN;
 630     nError = r.nError;
 631     nMode  = r.nMode;
 632     bHyperLink = r.bHyperLink;
 633     mbFromRangeName = r.mbFromRangeName;
 634     mbShareable = r.mbShareable;
 635     mbFinalized = r.mbFinalized;
 636     pCode  = nullptr;
 637     pRPN   = nullptr;
 638     FormulaToken** pp;
 639     if( nLen )
 640     {
 641         pCode.reset(new FormulaToken*[ nLen ]);
 642         pp = pCode.get();
 643         memcpy( pp, r.pCode.get(), nLen * sizeof( FormulaToken* ) );
 644         for( sal_uInt16 i = 0; i < nLen; i++ )
 645             (*pp++)->IncRef();
 646         mbFinalized = true;
 647     }
 648     if( nRPN )
 649     {
 650         pp = pRPN = new FormulaToken*[ nRPN ];
 651         memcpy( pp, r.pRPN, nRPN * sizeof( FormulaToken* ) );
 652         for( sal_uInt16 i = 0; i < nRPN; i++ )
 653             (*pp++)->IncRef();
 654     }
 655 }
 656
 657 void FormulaTokenArray::Move( FormulaTokenArray&& r )
 658 {
 659     pCode  = std::move(r.pCode);
 660     pRPN   = r.pRPN;
 661     r.pRPN = nullptr;
 662     nLen   = r.nLen;
 663     r.nLen = 0;
 664     nRPN   = r.nRPN;
 665     r.nRPN = 0;
 666     nError = r.nError;
 667     nMode  = r.nMode;
 668     bHyperLink = r.bHyperLink;
 669     mbFromRangeName = r.mbFromRangeName;
 670     mbShareable = r.mbShareable;
 671     mbFinalized = r.mbFinalized;
 672 }
 673
 674 /// Optimisation for efficiently creating StringXML placeholders
 675 void FormulaTokenArray::Assign( sal_uInt16 nCode, FormulaToken **pTokens )
 676 {
 677     assert( nLen == 0 );
 678     assert( pCode == nullptr );
 679
 680     nLen = nCode;
 681     pCode.reset(new FormulaToken*[ nLen ]);
 682     mbFinalized = true;
 683
 684     for( sal_uInt16 i = 0; i < nLen; i++ )
 685     {
 686         FormulaToken *t = pTokens[ i ];
 687         assert( t->GetOpCode() == ocStringXML );
 688         pCode[ i ] = t;
 689         t->IncRef();
 690     }
 691 }
 692
 693 FormulaTokenArray& FormulaTokenArray::operator=( const FormulaTokenArray& rArr )
 694 {
 695     if(this == &rArr)
 696         return *this;
 697
 698     Clear();
 699     Assign( rArr );
 700     return *this;
 701 }
 702
 703 FormulaTokenArray& FormulaTokenArray::operator=( FormulaTokenArray&& rArr )
 704 {
 705     Clear();
 706     Move( std::move(rArr) );
 707     return *this;
 708 }
 709
 710 void FormulaTokenArray::Clear()
 711 {
 712     if( nRPN ) DelRPN();
 713     if( pCode )
 714     {
 715         FormulaToken** p = pCode.get();
 716         for( sal_uInt16 i = 0; i < nLen; i++ )
 717         {
 718             (*p++)->DecRef();
 719         }
 720         pCode.reset();
 721     }
 722     pRPN = nullptr;
 723     nError = FormulaError::NONE;
 724     nLen = nRPN = 0;
 725     bHyperLink = false;
 726     mbFromRangeName = false;
 727     mbShareable = true;
 728     mbFinalized = false;
 729     ClearRecalcMode();
 730 }
 731
 732 void FormulaTokenArray::CheckToken( const FormulaToken& /*r*/ )
 733 {
 734     // Do nothing.
 735 }
 736
 737 void FormulaTokenArray::CheckAllRPNTokens()
 738 {
 739     if( nRPN )
 740     {
 741         FormulaToken** p = pRPN;
 742         for( sal_uInt16 i = 0; i < nRPN; i++ )
 743         {
 744             CheckToken( *p[ i ] );
 745         }
 746     }
 747 }
 748
 749 FormulaToken* FormulaTokenArray::AddToken( const FormulaToken& r )
 750 {
 751     return Add( r.Clone() );
 752 }
 753
 754 FormulaToken* FormulaTokenArray::MergeArray( )
 755 {
 756     return nullptr;
 757 }
 758
 759 FormulaToken* FormulaTokenArray::ReplaceToken( sal_uInt16 nOffset, FormulaToken* t,
 760         FormulaTokenArray::ReplaceMode eMode )
 761 {
 762     if (nOffset < nLen)
 763     {
 764         CheckToken(*t);
 765         t->IncRef();
 766         FormulaToken* p = pCode[nOffset];
 767         pCode[nOffset] = t;
 768         if (eMode == CODE_AND_RPN && p->GetRef() > 1)
 769         {
 770             for (sal_uInt16 i=0; i < nRPN; ++i)
 771             {
 772                 if (pRPN[i] == p)
 773                 {
 774                     t->IncRef();
 775                     pRPN[i] = t;
 776                     p->DecRef();
 777                     if (p->GetRef() == 1)
 778                         break;  // for
 779                 }
 780             }
 781         }
 782         p->DecRef();    // may be dead now
 783         return t;
 784     }
 785     else
 786     {
 787         t->DeleteIfZeroRef();
 788         return nullptr;
 789     }
 790 }
 791
 792 sal_uInt16 FormulaTokenArray::RemoveToken( sal_uInt16 nOffset, sal_uInt16 nCount )
 793 {
 794     if (nOffset < nLen)
 795     {
 796         SAL_WARN_IF( nOffset + nCount > nLen, "formula.core",
 797                 "FormulaTokenArray::RemoveToken - nOffset " << nOffset << " + nCount " << nCount << " > nLen " << nLen);
 798         const sal_uInt16 nStop = ::std::min( static_cast<sal_uInt16>(nOffset + nCount), nLen);
 799         nCount = nStop - nOffset;
 800         for (sal_uInt16 j = nOffset; j < nStop; ++j)
 801         {
 802             FormulaToken* p = pCode[j];
 803             if (p->GetRef() > 1)
 804             {
 805                 for (sal_uInt16 i=0; i < nRPN; ++i)
 806                 {
 807                     if (pRPN[i] == p)
 808                     {
 809                         // Shift remaining tokens in pRPN down.
 810                         for (sal_uInt16 x=i+1; x < nRPN; ++x)
 811                         {
 812                             pRPN[x-1] = pRPN[x];
 813                         }
 814                         --nRPN;
 815
 816                         p->DecRef();
 817                         if (p->GetRef() == 1)
 818                             break;  // for
 819                     }
 820                 }
 821             }
 822             p->DecRef();    // may be dead now
 823         }
 824
 825         // Shift remaining tokens in pCode down.
 826         for (sal_uInt16 x = nStop; x < nLen; ++x)
 827         {
 828             pCode[x-nCount] = pCode[x];
 829         }
 830         nLen -= nCount;
 831
 832         return nCount;
 833     }
 834     else
 835     {
 836         SAL_WARN("formula.core","FormulaTokenArray::RemoveToken - nOffset " << nOffset << " >= nLen " << nLen);
 837         return 0;
 838     }
 839 }
 840
 841 FormulaToken* FormulaTokenArray::Add( FormulaToken* t )
 842 {
 843     assert(!mbFinalized);
 844     if (mbFinalized)
 845     {
 846         t->DeleteIfZeroRef();
 847         return nullptr;
 848     }
 849
 850 // Allocating an array of size FORMULA_MAXTOKENS is simple, but that results in relatively large
 851 // allocations that malloc() implementations usually do not handle as efficiently as smaller
 852 // sizes (not only in terms of memory usage but also speed). Since most token arrays are going
 853 // to be small, start with a small array and resize only if needed. Eventually Finalize() will
 854 // reallocate the memory to size exactly matching the requirements.
 855     const size_t MAX_FAST_TOKENS = 32;
 856     if( !pCode )
 857         pCode.reset(new FormulaToken*[ MAX_FAST_TOKENS ]);
 858     if( nLen == MAX_FAST_TOKENS )
 859     {
 860         FormulaToken** tmp = new FormulaToken*[ FORMULA_MAXTOKENS ];
 861         std::copy(&pCode[0], &pCode[MAX_FAST_TOKENS], tmp);
 862         pCode.reset(tmp);
 863     }
 864     if( nLen < FORMULA_MAXTOKENS - 1 )
 865     {
 866         CheckToken(*t);
 867         pCode[ nLen++ ] = t;
 868         t->IncRef();
 869         if( t->GetOpCode() == ocArrayClose )
 870             return MergeArray();
 871         return t;
 872     }
 873     else
 874     {
 875         t->DeleteIfZeroRef();
 876         if ( nLen == FORMULA_MAXTOKENS - 1 )
 877         {
 878             t = new FormulaByteToken( ocStop );
 879             pCode[ nLen++ ] = t;
 880             t->IncRef();
 881         }
 882         return nullptr;
 883     }
 884 }
 885
 886 FormulaToken* FormulaTokenArray::AddString( const svl::SharedString& rStr )
 887 {
 888     return Add( new FormulaStringToken( rStr ) );
 889 }
 890
 891 FormulaToken* FormulaTokenArray::AddDouble( double fVal )
 892 {
 893     return Add( new FormulaDoubleToken( fVal ) );
 894 }
 895
 896 void FormulaTokenArray::AddExternal( const sal_Unicode* pStr )
 897 {
 898     AddExternal( OUString( pStr ) );
 899 }
 900
 901 FormulaToken* FormulaTokenArray::AddExternal( const OUString& rStr,
 902         OpCode eOp /* = ocExternal */ )
 903 {
 904     return Add( new FormulaExternalToken( eOp, rStr ) );
 905 }
 906
 907 FormulaToken* FormulaTokenArray::AddBad( const OUString& rStr )
 908 {
 909     return Add( new FormulaStringOpToken( ocBad, svl::SharedString( rStr ) ) ); // string not interned
 910 }
 911
 912 FormulaToken* FormulaTokenArray::AddStringXML( const OUString& rStr )
 913 {
 914     return Add( new FormulaStringOpToken( ocStringXML, svl::SharedString( rStr ) ) );   // string not interned
 915 }
 916
 917 FormulaToken* FormulaTokenArray::AddStringName( const OUString& rStr )
 918 {
 919     return Add( new FormulaStringOpToken( ocStringName, svl::SharedString( rStr ) ) );   // string not interned
 920 }
 921
 922 void FormulaTokenArray::AddRecalcMode( ScRecalcMode nBits )
 923 {
 924     const unsigned nExclusive = static_cast<sal_uInt8>(nBits & ScRecalcMode::EMask);
 925     if (nExclusive)
 926     {
 927         unsigned nExBit;
 928         if (nExclusive & (nExclusive - 1))
 929         {
 930             // More than one bit set, use highest priority.
 931             for (nExBit = 1; (nExBit & static_cast<sal_uInt8>(ScRecalcMode::EMask)) != 0; nExBit <<= 1)
 932             {
 933                 if (nExclusive & nExBit)
 934                     break;
 935             }
 936         }
 937         else
 938         {
 939             // Only one bit is set.
 940             nExBit = nExclusive;
 941         }
 942         // Set exclusive bit if priority is higher than existing.
 943         if (nExBit < static_cast<sal_uInt8>(nMode & ScRecalcMode::EMask))
 944             SetMaskedRecalcMode( static_cast<ScRecalcMode>(nExBit));
 945     }
 946     SetCombinedBitsRecalcMode( nBits );
 947 }
 948
 949
 950 bool FormulaTokenArray::HasMatrixDoubleRefOps() const
 951 {
 952     if ( !pRPN || !nRPN )
 953         return false;
 954
 955     // RPN-Interpreter simulation.
 956     // Simply assumes a double as return value of each function.
 957     std::unique_ptr<FormulaToken*[]> pStack(new FormulaToken* [nRPN]);
 958     FormulaToken* pResult = new FormulaDoubleToken( 0.0 );
 959     short sp = 0;
 960     for ( auto t: RPNTokens() )
 961     {
 962         OpCode eOp = t->GetOpCode();
 963         sal_uInt8 nParams = t->GetParamCount();
 964         switch ( eOp )
 965         {
 966             case ocAdd :
 967             case ocSub :
 968             case ocMul :
 969             case ocDiv :
 970             case ocPow :
 971             case ocPower :
 972             case ocAmpersand :
 973             case ocEqual :
 974             case ocNotEqual :
 975             case ocLess :
 976             case ocGreater :
 977             case ocLessEqual :
 978             case ocGreaterEqual :
 979             {
 980                 for ( sal_uInt8 k = nParams; k; k-- )
 981                 {
 982                     if ( sp >= k && pStack[sp-k]->GetType() == svDoubleRef )
 983                     {
 984                         pResult->Delete();
 985                         return true;
 986                     }
 987                 }
 988             }
 989             break;
 990             default:
 991             {
 992                 // added to avoid warnings
 993             }
 994         }
 995         if ( eOp == ocPush || lcl_IsReference( eOp, t->GetType() )  )
 996             pStack[sp++] = t;
 997         else if (FormulaCompiler::IsOpCodeJumpCommand( eOp ))
 998         {   // ignore Jumps, pop previous Result (Condition)
 999             if ( sp )
1000                 --sp;
1001         }
1002         else
1003         {   // pop parameters, push result
1004             sp = sal::static_int_cast<short>( sp - nParams );
1005             if ( sp < 0 )
1006             {
1007                 SAL_WARN("formula.core", "FormulaTokenArray::HasMatrixDoubleRefOps: sp < 0" );
1008                 sp = 0;
1009             }
1010             pStack[sp++] = pResult;
1011         }
1012     }
1013     pResult->Delete();
1014
1015     return false;
1016 }
1017
1018 // --- Formula rewrite of a token array
1019
1020 inline bool MissingConventionODF::isRewriteNeeded( OpCode eOp ) const
1021 {
1022     switch (eOp)
1023     {
1024         case ocGammaDist:
1025         case ocPoissonDist:
1026         case ocAddress:
1027         case ocLogInv:
1028         case ocLogNormDist:
1029         case ocNormDist:
1030             return true;
1031         case ocMissing:
1032         case ocLog:
1033             return isPODF();    // rewrite only for PODF
1034         case ocDBCount:
1035         case ocDBCount2:
1036             return isODFF();    // rewrite only for ODFF
1037         default:
1038             return false;
1039     }
1040 }
1041
1042 /*
1043  fdo 81596
1044 To be implemented yet:
1045   ocExternal:    ?
1046   ocMacro:       ?
1047   ocIndex:       INDEX() ?
1048 */
1049 inline bool MissingConventionOOXML::isRewriteNeeded( OpCode eOp )
1050 {
1051     switch (eOp)
1052     {
1053         case ocIf:
1054
1055         case ocExternal:
1056         case ocEuroConvert:
1057         case ocMacro:
1058
1059         case ocRound:
1060         case ocRoundUp:
1061         case ocRoundDown:
1062
1063         case ocIndex:
1064
1065         case ocCeil:
1066         case ocFloor:
1067
1068         case ocGammaDist:
1069         case ocFDist_LT:
1070         case ocPoissonDist:
1071         case ocNormDist:
1072         case ocLogInv:
1073         case ocLogNormDist:
1074         case ocHypGeomDist:
1075
1076         case ocDBCount:
1077         case ocDBCount2:
1078             return true;
1079
1080         default:
1081             return false;
1082     }
1083 }
1084
1085 namespace {
1086
1087 class FormulaMissingContext
1088 {
1089     public:
1090             const FormulaToken* mpFunc;
1091             int                 mnCurArg;
1092
1093                     void    Clear() { mpFunc = nullptr; mnCurArg = 0; }
1094             inline  bool    AddDefaultArg( FormulaTokenArray* pNewArr, int nArg, double f ) const;
1095                     bool    AddMissingExternal( FormulaTokenArray* pNewArr ) const;
1096                     bool    AddMissing( FormulaTokenArray *pNewArr, const MissingConvention & rConv  ) const;
1097                     void    AddMoreArgs( FormulaTokenArray *pNewArr, const MissingConvention & rConv  ) const;
1098 };
1099
1100 }
1101
1102 void FormulaMissingContext::AddMoreArgs( FormulaTokenArray *pNewArr, const MissingConvention & rConv  ) const
1103 {
1104     if ( !mpFunc )
1105         return;
1106
1107     switch (rConv.getConvention())
1108     {
1109         case MissingConvention::FORMULA_MISSING_CONVENTION_ODFF:
1110         case MissingConvention::FORMULA_MISSING_CONVENTION_PODF:
1111             {
1112                 switch (mpFunc->GetOpCode())
1113                 {
1114                     case ocGammaDist:
1115                         if (mnCurArg == 2)
1116                         {
1117                             pNewArr->AddOpCode( ocSep );
1118                             pNewArr->AddDouble( 1.0 );      // 4th, Cumulative=true()
1119                         }
1120                         break;
1121                     case ocPoissonDist:
1122                         if (mnCurArg == 1)
1123                         {
1124                             pNewArr->AddOpCode( ocSep );
1125                             pNewArr->AddDouble( 1.0 );      // 3rd, Cumulative=true()
1126                         }
1127                         break;
1128                     case ocNormDist:
1129                         if ( mnCurArg == 2 )
1130                         {
1131                             pNewArr->AddOpCode( ocSep );
1132                             pNewArr->AddDouble( 1.0 );      // 4th, Cumulative=true()
1133                         }
1134                         break;
1135                     case ocLogInv:
1136                     case ocLogNormDist:
1137                         if ( mnCurArg == 0 )
1138                         {
1139                             pNewArr->AddOpCode( ocSep );
1140                             pNewArr->AddDouble( 0.0 );      // 2nd, mean = 0.0
1141                         }
1142                         if ( mnCurArg <= 1 )
1143                         {
1144                             pNewArr->AddOpCode( ocSep );
1145                             pNewArr->AddDouble( 1.0 );      // 3rd, standard deviation = 1.0
1146                         }
1147                         break;
1148                     case ocLog:
1149                         if ( rConv.isPODF() && mnCurArg == 0 )
1150                         {
1151                             pNewArr->AddOpCode( ocSep );
1152                             pNewArr->AddDouble( 10.0 );     // 2nd, basis 10
1153                         }
1154                         break;
1155                     default:
1156                         break;
1157                 }
1158             }
1159             break;
1160         case MissingConvention::FORMULA_MISSING_CONVENTION_OOXML:
1161             {
1162                 switch (mpFunc->GetOpCode())
1163                 {
1164                     case ocIf:
1165                         if( mnCurArg == 0 )
1166                         {
1167                             // Excel needs at least two parameters in IF function
1168                             pNewArr->AddOpCode( ocSep );
1169                             pNewArr->AddOpCode( ocTrue );   // 2nd, true() as function
1170                             pNewArr->AddOpCode( ocOpen );   // so the result is of logical type
1171                             pNewArr->AddOpCode( ocClose );  // and survives roundtrip
1172                         }
1173                         break;
1174
1175                     case ocEuroConvert:
1176                         if ( mnCurArg == 2 )
1177                         {
1178                             pNewArr->AddOpCode( ocSep );
1179                             pNewArr->AddDouble( 0.0 );      // 4th, FullPrecision = false()
1180                         }
1181                         break;
1182
1183                     case ocPoissonDist:
1184                         if (mnCurArg == 1)
1185                         {
1186                             pNewArr->AddOpCode( ocSep );
1187                             pNewArr->AddDouble( 1.0 );      // 3rd, Cumulative=true()
1188                         }
1189                         break;
1190
1191                     case ocGammaDist:
1192                     case ocFDist_LT:
1193                     case ocNormDist:
1194                         if (mnCurArg == 2)
1195                         {
1196                             pNewArr->AddOpCode( ocSep );
1197                             pNewArr->AddDouble( 1.0 );      // 4th, Cumulative=true()
1198                         }
1199                         break;
1200
1201                     case ocLogInv:
1202                     case ocLogNormDist:
1203                         if ( mnCurArg == 0 )
1204                         {
1205                             pNewArr->AddOpCode( ocSep );
1206                             pNewArr->AddDouble( 0.0 );      // 2nd, mean = 0.0
1207                         }
1208                         if ( mnCurArg <= 1 )
1209                         {
1210                             pNewArr->AddOpCode( ocSep );
1211                             pNewArr->AddDouble( 1.0 );      // 3rd, standard deviation = 1.0
1212                         }
1213                         break;
1214
1215                     case ocHypGeomDist:
1216                         if ( mnCurArg == 3 )
1217                         {
1218                             pNewArr->AddOpCode( ocSep );
1219                             pNewArr->AddDouble( 0.0 );      // 5th, Cumulative = false()
1220                         }
1221                         break;
1222
1223                     case ocRound:
1224                     case ocRoundUp:
1225                     case ocRoundDown:
1226                         if( mnCurArg == 0 )
1227                         {
1228                             // ROUND, ROUNDUP, ROUNDDOWN functions are fixed to 2 parameters in Excel
1229                             pNewArr->AddOpCode( ocSep );
1230                             pNewArr->AddDouble( 0.0 );      // 2nd, 0.0
1231                         }
1232                         break;
1233
1234                     default:
1235                         break;
1236                 }
1237             }
1238             break;
1239     }
1240
1241 }
1242
1243 inline bool FormulaMissingContext::AddDefaultArg( FormulaTokenArray* pNewArr, int nArg, double f ) const
1244 {
1245     if (mnCurArg == nArg)
1246     {
1247         pNewArr->AddDouble( f );
1248         return true;
1249     }
1250     return false;
1251 }
1252
1253 bool FormulaMissingContext::AddMissingExternal( FormulaTokenArray *pNewArr ) const
1254 {
1255     // Only called for PODF, not ODFF. No need to distinguish.
1256
1257     const OUString &rName = mpFunc->GetExternal();
1258
1259     // initial (fast) checks:
1260     sal_Int32 nLength = rName.getLength();
1261     if (!nLength)
1262         return false;
1263
1264     sal_Unicode nLastChar = rName[ nLength - 1];
1265     if ( nLastChar != 't' && nLastChar != 'm' )
1266         return false;
1267
1268     if (rName.equalsIgnoreAsciiCase(
1269                 "com.sun.star.sheet.addin.Analysis.getAccrint" ))
1270     {
1271         return AddDefaultArg( pNewArr, 4, 1000.0 );
1272     }
1273     if (rName.equalsIgnoreAsciiCase(
1274                 "com.sun.star.sheet.addin.Analysis.getAccrintm" ))
1275     {
1276         return AddDefaultArg( pNewArr, 3, 1000.0 );
1277     }
1278     return false;
1279 }
1280
1281 bool FormulaMissingContext::AddMissing( FormulaTokenArray *pNewArr, const MissingConvention & rConv  ) const
1282 {
1283     if ( !mpFunc )
1284         return false;
1285
1286     bool bRet = false;
1287     const OpCode eOp = mpFunc->GetOpCode();
1288
1289     switch (rConv.getConvention())
1290     {
1291         case MissingConvention::FORMULA_MISSING_CONVENTION_ODFF:
1292             {
1293                 // Add for ODFF
1294                 switch (eOp)
1295                 {
1296                     case ocAddress:
1297                         return AddDefaultArg( pNewArr, 2, 1.0 );    // abs
1298                     default:
1299                         break;
1300                 }
1301             }
1302             break;
1303         case MissingConvention::FORMULA_MISSING_CONVENTION_PODF:
1304             {
1305                 // Add for PODF
1306                 switch (eOp)
1307                 {
1308                     case ocAddress:
1309                         return AddDefaultArg( pNewArr, 2, 1.0 );    // abs
1310                     case ocFixed:
1311                         return AddDefaultArg( pNewArr, 1, 2.0 );
1312                     case ocBetaDist:
1313                     case ocBetaInv:
1314                     case ocPMT:
1315                         return AddDefaultArg( pNewArr, 3, 0.0 );
1316                     case ocIpmt:
1317                     case ocPpmt:
1318                         return AddDefaultArg( pNewArr, 4, 0.0 );
1319                     case ocPV:
1320                     case ocFV:
1321                         bRet |= AddDefaultArg( pNewArr, 2, 0.0 );   // pmt
1322                         bRet |= AddDefaultArg( pNewArr, 3, 0.0 );   // [fp]v
1323                         break;
1324                     case ocRate:
1325                         bRet |= AddDefaultArg( pNewArr, 1, 0.0 );   // pmt
1326                         bRet |= AddDefaultArg( pNewArr, 3, 0.0 );   // fv
1327                         bRet |= AddDefaultArg( pNewArr, 4, 0.0 );   // type
1328                         break;
1329                     case ocExternal:
1330                         return AddMissingExternal( pNewArr );
1331
1332                         // --- more complex cases ---
1333
1334                     case ocOffset:
1335                         // FIXME: rather tough
1336                         // if arg 3 (height) omitted, export arg1 (rows)
1337                         break;
1338                     default:
1339                         break;
1340                 }
1341             }
1342             break;
1343         case MissingConvention::FORMULA_MISSING_CONVENTION_OOXML:
1344             {
1345                 switch (eOp)
1346                 {
1347                     case ocExternal:
1348                         return AddMissingExternal( pNewArr );
1349                     default:
1350                         break;
1351                 }
1352             }
1353             break;
1354     }
1355
1356     return bRet;
1357 }
1358
1359 bool FormulaTokenArray::NeedsPodfRewrite( const MissingConventionODF & rConv )
1360 {
1361     for ( auto i: Tokens()  )
1362     {
1363         if ( rConv.isRewriteNeeded( i->GetOpCode()))
1364             return true;
1365     }
1366     return false;
1367 }
1368
1369 bool FormulaTokenArray::NeedsOoxmlRewrite()
1370 {
1371     for ( auto i: Tokens() )
1372     {
1373         if ( MissingConventionOOXML::isRewriteNeeded( i->GetOpCode()))
1374             return true;
1375     }
1376     return false;
1377 }
1378
1379
1380 FormulaTokenArray * FormulaTokenArray::RewriteMissing( const MissingConvention & rConv )
1381 {
1382     const size_t nAlloc = 256;
1383     FormulaMissingContext aCtx[ nAlloc ];
1384
1385     /* TODO: with some effort we might be able to merge the two almost
1386      * identical function stacks into one and generalize things, otherwise
1387      * adding yet another "omit argument" would be copypasta. */
1388
1389     int aOpCodeAddressStack[ nAlloc ];  // use of ADDRESS() function
1390     const int nOmitAddressArg = 3;      // ADDRESS() 4th parameter A1/R1C1
1391
1392     int aOpCodeDcountStack[ nAlloc ];   // use of DCOUNT()/DCOUNTA() function
1393     const int nOmitDcountArg = 1;       // DCOUNT() and DCOUNTA() 2nd parameter DatabaseField if 0
1394
1395     sal_uInt16 nTokens = GetLen() + 1;
1396     FormulaMissingContext* pCtx = (nAlloc < nTokens ? new FormulaMissingContext[nTokens] : &aCtx[0]);
1397     int* pOcas = (nAlloc < nTokens ? new int[nTokens] : &aOpCodeAddressStack[0]);
1398     int* pOcds = (nAlloc < nTokens ? new int[nTokens] : &aOpCodeDcountStack[0]);
1399     // Never go below 0, never use 0, mpFunc always NULL.
1400     pCtx[0].Clear();
1401     int nFn = 0;
1402     int nOcas = 0;
1403     int nOcds = 0;
1404
1405     FormulaTokenArray *pNewArr = new FormulaTokenArray;
1406     // At least ScRecalcMode::ALWAYS needs to be set.
1407     pNewArr->AddRecalcMode( GetRecalcMode());
1408
1409     FormulaTokenArrayPlainIterator aIter(*this);
1410     for ( FormulaToken *pCur = aIter.First(); pCur; pCur = aIter.Next() )
1411     {
1412         bool bAdd = true;
1413         // Don't write the expression of the new inserted ADDRESS() parameter.
1414         // Do NOT omit the new second parameter of INDIRECT() though. If that
1415         // was done for both, INDIRECT() actually could calculate different and
1416         // valid (but wrong) results with the then changed return value of
1417         // ADDRESS(). Better let it generate an error instead.
1418         for (int i = nOcas; i-- > 0 && bAdd; )
1419         {
1420             if (pCtx[ pOcas[ i ] ].mnCurArg == nOmitAddressArg)
1421             {
1422                 // Omit everything except a trailing separator, the leading
1423                 // separator is omitted below. The other way around would leave
1424                 // an extraneous separator if no parameter followed.
1425                 if (pOcas[ i ] != nFn || pCur->GetOpCode() != ocSep)
1426                     bAdd = false;
1427             }
1428         }
1429         // Strip the 2nd argument (leaving empty) of DCOUNT() and DCOUNTA() if
1430         // it is 0.
1431         for (int i = nOcds; i-- > 0 && bAdd; )
1432         {
1433             if (pCtx[ pOcds[ i ] ].mnCurArg == nOmitDcountArg)
1434             {
1435                 // Omit only a literal 0 value, nothing else.
1436                 if (pOcds[ i ] == nFn && pCur->GetOpCode() == ocPush && pCur->GetType() == svDouble &&
1437                         pCur->GetDouble() == 0.0)
1438                 {
1439                     // No other expression, between separators.
1440                     FormulaToken* p = aIter.PeekPrevNoSpaces();
1441                     if (p && p->GetOpCode() == ocSep)
1442                     {
1443                         p = aIter.PeekNextNoSpaces();
1444                         if (p && p->GetOpCode() == ocSep)
1445                             bAdd = false;
1446                     }
1447                 }
1448             }
1449         }
1450         switch ( pCur->GetOpCode() )
1451         {
1452             case ocOpen:
1453                 {
1454                     ++nFn;      // all following operations on _that_ function
1455                     pCtx[ nFn ].mpFunc = aIter.PeekPrevNoSpaces();
1456                     pCtx[ nFn ].mnCurArg = 0;
1457                     if (rConv.isPODF() && pCtx[ nFn ].mpFunc && pCtx[ nFn ].mpFunc->GetOpCode() == ocAddress)
1458                         pOcas[ nOcas++ ] = nFn;     // entering ADDRESS() if PODF
1459                     else if ((rConv.isODFF() || rConv.isOOXML()) && pCtx[ nFn ].mpFunc)
1460                     {
1461                         OpCode eOp = pCtx[ nFn ].mpFunc->GetOpCode();
1462                         if (eOp == ocDBCount || eOp == ocDBCount2)
1463                             pOcds[ nOcds++ ] = nFn;     // entering DCOUNT() or DCOUNTA() if ODFF or OOXML
1464                     }
1465                 }
1466             break;
1467             case ocClose:
1468                 pCtx[ nFn ].AddMoreArgs( pNewArr, rConv );
1469                 SAL_WARN_IF(nFn <= 0, "formula.core", "FormulaTokenArray::RewriteMissing: underflow");
1470                 if (nOcas > 0 && pOcas[ nOcas-1 ] == nFn)
1471                     --nOcas;                    // leaving ADDRESS()
1472                 else if (nOcds > 0 && pOcds[ nOcds-1 ] == nFn)
1473                     --nOcds;                    // leaving DCOUNT() or DCOUNTA()
1474                 if (nFn > 0)
1475                     --nFn;
1476                 break;
1477             case ocSep:
1478                 pCtx[ nFn ].mnCurArg++;
1479                 // Omit leading separator of ADDRESS() parameter.
1480                 if (nOcas && pOcas[ nOcas-1 ] == nFn && pCtx[ nFn ].mnCurArg == nOmitAddressArg)
1481                 {
1482                     bAdd = false;
1483                 }
1484                 break;
1485             case ocMissing:
1486                 if ( bAdd )
1487                     bAdd = !pCtx[ nFn ].AddMissing( pNewArr, rConv );
1488                 break;
1489             default:
1490                 break;
1491         }
1492         if (bAdd)
1493         {
1494             OpCode eOp = pCur->GetOpCode();
1495             if ( ( eOp == ocCeil || eOp == ocFloor ||
1496                    ( eOp == ocLogNormDist && pCur->GetByte() == 4 ) ) &&
1497                  rConv.getConvention() == MissingConvention::FORMULA_MISSING_CONVENTION_OOXML )
1498             {
1499                 switch ( eOp )
1500                 {
1501                     case ocCeil :
1502                         eOp = ocCeil_Math;
1503                         break;
1504                     case ocFloor :
1505                         eOp = ocFloor_Math;
1506                         break;
1507                     case ocLogNormDist :
1508                         eOp = ocLogNormDist_MS;
1509                         break;
1510                     default :
1511                         eOp = ocNone;
1512                         break;
1513                 }
1514                 FormulaToken *pToken = new FormulaToken( svByte, eOp );
1515                 pNewArr->Add( pToken );
1516             }
1517             else if ( eOp == ocHypGeomDist &&
1518                       rConv.getConvention() == MissingConvention::FORMULA_MISSING_CONVENTION_OOXML )
1519             {
1520                 FormulaToken *pToken = new FormulaToken( svByte, ocHypGeomDist_MS );
1521                 pNewArr->Add( pToken );
1522             }
1523             else
1524                 pNewArr->AddToken( *pCur );
1525         }
1526     }
1527
1528     if (pOcds != &aOpCodeDcountStack[0])
1529         delete [] pOcds;
1530     if (pOcas != &aOpCodeAddressStack[0])
1531         delete [] pOcas;
1532     if (pCtx != &aCtx[0])
1533         delete [] pCtx;
1534
1535     return pNewArr;
1536 }
1537
1538 namespace {
1539 inline bool isWhitespace( OpCode eOp ) { return eOp == ocSpaces || eOp == ocWhitespace; }
1540 }
1541
1542 bool FormulaTokenArray::MayReferenceFollow()
1543 {
1544     if ( !pCode || nLen <= 0 )
1545         return false;
1546
1547     // ignore trailing spaces
1548     sal_uInt16 i = nLen - 1;
1549     while (i > 0 && isWhitespace( pCode[i]->GetOpCode()))
1550     {
1551         --i;
1552     }
1553     if (i > 0 || !isWhitespace( pCode[i]->GetOpCode()))
1554     {
1555         OpCode eOp = pCode[i]->GetOpCode();
1556         if ( (SC_OPCODE_START_BIN_OP <= eOp && eOp < SC_OPCODE_STOP_BIN_OP ) ||
1557              (SC_OPCODE_START_UN_OP <= eOp && eOp < SC_OPCODE_STOP_UN_OP ) ||
1558              eOp == SC_OPCODE_OPEN || eOp == SC_OPCODE_SEP )
1559         {
1560             return true;
1561         }
1562     }
1563     return false;
1564 }
1565 FormulaToken* FormulaTokenArray::AddOpCode( OpCode eOp )
1566 {
1567     FormulaToken* pRet = nullptr;
1568     switch ( eOp )
1569     {
1570         case ocOpen:
1571         case ocClose:
1572         case ocSep:
1573         case ocArrayOpen:
1574         case ocArrayClose:
1575         case ocArrayRowSep:
1576         case ocArrayColSep:
1577             pRet = new FormulaToken( svSep,eOp );
1578             break;
1579         case ocIf:
1580         case ocIfError:
1581         case ocIfNA:
1582         case ocChoose:
1583         case ocLet:
1584             {
1585                 short nJump[FORMULA_MAXPARAMS + 1];
1586                 if ( eOp == ocIf )
1587                     nJump[ 0 ] = 3;
1588                 else if ( eOp == ocChoose )
1589                     nJump[ 0 ] = FORMULA_MAXJUMPCOUNT + 1;
1590                 else if ( eOp == ocLet )
1591                     nJump[ 0 ] = FORMULA_MAXPARAMS + 1;
1592                 else
1593                     nJump[ 0 ] = 2;
1594                 pRet = new FormulaJumpToken( eOp, nJump );
1595             }
1596             break;
1597         default:
1598             pRet = new FormulaByteToken( eOp, 0, ParamClass::Unknown );
1599             break;
1600     }
1601     return Add( pRet );
1602 }
1603
1604 void FormulaTokenArray::ReinternStrings( svl::SharedStringPool& rPool )
1605 {
1606     for (auto i: Tokens())
1607     {
1608         switch (i->GetType())
1609         {
1610             case svString:
1611                 i->SetString( rPool.intern( i->GetString().getString()));
1612                 break;
1613             default:
1614                 ;   // nothing
1615         }
1616     }
1617 }
1618
1619
1620 /*----------------------------------------------------------------------*/
1621
1622 FormulaTokenIterator::Item::Item(const FormulaTokenArray* pArray, short pc, short stop) :
1623     pArr(pArray), nPC(pc), nStop(stop)
1624 {
1625 }
1626
1627 FormulaTokenIterator::FormulaTokenIterator( const FormulaTokenArray& rArr )
1628     : maStack{ FormulaTokenIterator::Item(&rArr, -1, SHRT_MAX) }
1629 {
1630 }
1631
1632 FormulaTokenIterator::~FormulaTokenIterator()
1633 {
1634 }
1635
1636 void FormulaTokenIterator::Push( const FormulaTokenArray* pArr )
1637 {
1638     FormulaTokenIterator::Item item(pArr, -1, SHRT_MAX);
1639
1640     maStack.push_back(item);
1641 }
1642
1643 void FormulaTokenIterator::Pop()
1644 {
1645     maStack.pop_back();
1646 }
1647
1648 void FormulaTokenIterator::Reset()
1649 {
1650     while( maStack.size() > 1 )
1651         maStack.pop_back();
1652
1653     maStack.back().nPC = -1;
1654 }
1655
1656 FormulaToken* FormulaTokenArrayPlainIterator::GetNextName()
1657 {
1658     if( mpFTA->GetArray() )
1659     {
1660         while ( mnIndex < mpFTA->GetLen() )
1661         {
1662             FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ];
1663             if( t->GetType() == svIndex )
1664                 return t;
1665         }
1666     }
1667     return nullptr;
1668 }
1669
1670 FormulaToken* FormulaTokenArrayPlainIterator::GetNextStringName()
1671 {
1672     if (mpFTA->GetArray())
1673     {
1674         while (mnIndex < mpFTA->GetLen())
1675         {
1676             FormulaToken* t = mpFTA->GetArray()[mnIndex++];
1677             if (t->GetType() == svString && t->GetOpCode() == ocStringName)
1678                 return t;
1679         }
1680     }
1681     return nullptr;
1682 }
1683
1684 const FormulaToken* FormulaTokenIterator::Next()
1685 {
1686     const FormulaToken* t = GetNonEndOfPathToken( ++maStack.back().nPC );
1687     if( !t && maStack.size() > 1 )
1688     {
1689         Pop();
1690         t = Next();
1691     }
1692     return t;
1693 }
1694
1695 const FormulaToken* FormulaTokenIterator::PeekNextOperator()
1696 {
1697     const FormulaToken* t = nullptr;
1698     short nIdx = maStack.back().nPC;
1699     for (;;)
1700     {
1701         t = GetNonEndOfPathToken( ++nIdx);
1702         if (t == nullptr || t->GetOpCode() != ocPush)
1703             break;   // ignore operands
1704     }
1705     if (!t && maStack.size() > 1)
1706     {
1707         FormulaTokenIterator::Item aHere = maStack.back();
1708         maStack.pop_back();
1709         t = PeekNextOperator();
1710         maStack.push_back(aHere);
1711     }
1712     return t;
1713 }
1714
1715 //! The nPC counts after a Push() are -1
1716
1717 void FormulaTokenIterator::Jump( short nStart, short nNext, short nStop )
1718 {
1719     maStack.back().nPC = nNext;
1720     if( nStart != nNext )
1721     {
1722         Push( maStack.back().pArr );
1723         maStack.back().nPC = nStart;
1724         maStack.back().nStop = nStop;
1725     }
1726 }
1727
1728 void FormulaTokenIterator::ReInit( const FormulaTokenArray& rArr )
1729 {
1730     maStack.clear();
1731     Push( &rArr );
1732 }
1733
1734 const FormulaToken* FormulaTokenIterator::GetNonEndOfPathToken( short nIdx ) const
1735 {
1736     FormulaTokenIterator::Item cur = maStack.back();
1737
1738     if (nIdx < cur.pArr->GetCodeLen() && nIdx < cur.nStop)
1739     {
1740         const FormulaToken* t = cur.pArr->GetCode()[ nIdx ];
1741         // such an OpCode ends an IF() or CHOOSE() path
1742         return (t->GetOpCode() == ocSep || t->GetOpCode() == ocClose) ? nullptr : t;
1743     }
1744     return nullptr;
1745 }
1746
1747 bool FormulaTokenIterator::IsEndOfPath() const
1748 {
1749     return GetNonEndOfPathToken( maStack.back().nPC + 1) == nullptr;
1750 }
1751
1752 FormulaToken* FormulaTokenArrayPlainIterator::GetNextReference()
1753 {
1754     while( mnIndex < mpFTA->GetLen() )
1755     {
1756         FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ];
1757         switch( t->GetType() )
1758         {
1759             case svSingleRef:
1760             case svDoubleRef:
1761             case svExternalSingleRef:
1762             case svExternalDoubleRef:
1763                 return t;
1764             default:
1765             {
1766                 // added to avoid warnings
1767             }
1768         }
1769     }
1770     return nullptr;
1771 }
1772
1773 FormulaToken* FormulaTokenArrayPlainIterator::GetNextColRowName()
1774 {
1775     while( mnIndex < mpFTA->GetLen() )
1776     {
1777         FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ];
1778         if ( t->GetOpCode() == ocColRowName )
1779             return t;
1780     }
1781     return nullptr;
1782 }
1783
1784 FormulaToken* FormulaTokenArrayPlainIterator::GetNextReferenceRPN()
1785 {
1786     while( mnIndex < mpFTA->GetCodeLen() )
1787     {
1788         FormulaToken* t = mpFTA->GetCode()[ mnIndex++ ];
1789         switch( t->GetType() )
1790         {
1791             case svSingleRef:
1792             case svDoubleRef:
1793             case svExternalSingleRef:
1794             case svExternalDoubleRef:
1795                 return t;
1796             default:
1797             {
1798                 // added to avoid warnings
1799             }
1800         }
1801     }
1802     return nullptr;
1803 }
1804
1805 FormulaToken* FormulaTokenArrayPlainIterator::GetNextReferenceOrName()
1806 {
1807     if( !mpFTA->GetArray() )
1808         return nullptr;
1809
1810     while ( mnIndex < mpFTA->GetLen() )
1811     {
1812         FormulaToken* t = mpFTA->GetArray()[ mnIndex++ ];
1813         switch( t->GetType() )
1814         {
1815             case svSingleRef:
1816             case svDoubleRef:
1817             case svIndex:
1818             case svExternalSingleRef:
1819             case svExternalDoubleRef:
1820             case svExternalName:
1821                 return t;
1822             default:
1823             {
1824                 // added to avoid warnings
1825             }
1826          }
1827     }
1828     return nullptr;
1829 }
1830
1831 FormulaToken* FormulaTokenArrayPlainIterator::Next()
1832 {
1833     if( mpFTA->GetArray() && mnIndex < mpFTA->GetLen() )
1834         return mpFTA->GetArray()[ mnIndex++ ];
1835     else
1836         return nullptr;
1837 }
1838
1839 FormulaToken* FormulaTokenArrayPlainIterator::NextNoSpaces()
1840 {
1841     if( mpFTA->GetArray() )
1842     {
1843         while ((mnIndex < mpFTA->GetLen()) && isWhitespace( mpFTA->GetArray()[ mnIndex ]->GetOpCode()))
1844             ++mnIndex;
1845         if( mnIndex < mpFTA->GetLen() )
1846             return mpFTA->GetArray()[ mnIndex++ ];
1847     }
1848     return nullptr;
1849 }
1850
1851 FormulaToken* FormulaTokenArrayPlainIterator::NextRPN()
1852 {
1853     if( mpFTA->GetCode() && mnIndex < mpFTA->GetCodeLen() )
1854         return mpFTA->GetCode()[ mnIndex++ ];
1855     else
1856         return nullptr;
1857 }
1858
1859 FormulaToken* FormulaTokenArrayPlainIterator::PrevRPN()
1860 {
1861     if( mpFTA->GetCode() && mnIndex )
1862         return mpFTA->GetCode()[ --mnIndex ];
1863     else
1864         return nullptr;
1865 }
1866
1867 FormulaToken* FormulaTokenArrayPlainIterator::PeekNext()
1868 {
1869     if( mpFTA->GetArray() && mnIndex < mpFTA->GetLen() )
1870         return mpFTA->GetArray()[ mnIndex ];
1871     else
1872         return nullptr;
1873 }
1874
1875 FormulaToken* FormulaTokenArrayPlainIterator::PeekNextNoSpaces() const
1876 {
1877     if( mpFTA->GetArray() && mnIndex < mpFTA->GetLen() )
1878     {
1879         sal_uInt16 j = mnIndex;
1880         while (j < mpFTA->GetLen() && isWhitespace( mpFTA->GetArray()[j]->GetOpCode()))
1881             j++;
1882         if ( j < mpFTA->GetLen() )
1883             return mpFTA->GetArray()[ j ];
1884         else
1885             return nullptr;
1886     }
1887     else
1888         return nullptr;
1889 }
1890
1891 FormulaToken* FormulaTokenArrayPlainIterator::PeekPrevNoSpaces() const
1892 {
1893     if( mpFTA->GetArray() && mnIndex > 1 )
1894     {
1895         sal_uInt16 j = mnIndex - 2;
1896         while (isWhitespace( mpFTA->GetArray()[j]->GetOpCode()) && j > 0 )
1897             j--;
1898         if (j > 0 || !isWhitespace( mpFTA->GetArray()[j]->GetOpCode()))
1899             return mpFTA->GetArray()[ j ];
1900         else
1901             return nullptr;
1902     }
1903     else
1904         return nullptr;
1905 }
1906
1907 void FormulaTokenArrayPlainIterator::AfterRemoveToken( sal_uInt16 nOffset, sal_uInt16 nCount )
1908 {
1909     const sal_uInt16 nStop = std::min( static_cast<sal_uInt16>(nOffset + nCount), mpFTA->GetLen());
1910
1911     if (mnIndex >= nOffset)
1912     {
1913         if (mnIndex < nStop)
1914             mnIndex = nOffset + 1;
1915         else
1916             mnIndex -= nStop - nOffset;
1917     }
1918 }
1919
1920 // real implementations of virtual functions
1921
1922 sal_Int16 FormulaDoubleToken::GetDoubleType() const
1923 {
1924     // This is a plain double value without type information, don't emit a
1925     // warning via FormulaToken::GetDoubleType().
1926     return 0;
1927 }
1928
1929 bool FormulaDoubleToken::operator==( const FormulaToken& r ) const
1930 {
1931     return FormulaToken::operator==( r ) && fDouble == r.GetDouble();
1932 }
1933
1934 sal_Int16 FormulaTypedDoubleToken::GetDoubleType() const
1935 {
1936     return mnType;
1937 }
1938
1939 void FormulaTypedDoubleToken::SetDoubleType( sal_Int16 nType )
1940 {
1941     mnType = nType;
1942 }
1943
1944 bool FormulaTypedDoubleToken::operator==( const FormulaToken& r ) const
1945 {
1946     return FormulaDoubleToken::operator==( r ) && mnType == r.GetDoubleType();
1947 }
1948
1949 FormulaStringToken::FormulaStringToken( svl::SharedString r ) :
1950     FormulaToken( svString ), maString(std::move( r ))
1951 {
1952 }
1953
1954 FormulaStringToken::FormulaStringToken( const FormulaStringToken& r ) :
1955     FormulaToken( r ), maString( r.maString ) {}
1956
1957 FormulaToken* FormulaStringToken::Clone() const
1958 {
1959     return new FormulaStringToken(*this);
1960 }
1961
1962 const svl::SharedString & FormulaStringToken::GetString() const
1963 {
1964     return maString;
1965 }
1966
1967 void FormulaStringToken::SetString( const svl::SharedString& rStr )
1968 {
1969     maString = rStr;
1970 }
1971
1972 bool FormulaStringToken::operator==( const FormulaToken& r ) const
1973 {
1974     return FormulaToken::operator==( r ) && maString == r.GetString();
1975 }
1976
1977 FormulaStringOpToken::FormulaStringOpToken( OpCode e, svl::SharedString r ) :
1978     FormulaByteToken( e, 0, svString, ParamClass::Unknown ), maString(std::move( r )) {}
1979
1980 FormulaStringOpToken::FormulaStringOpToken( const FormulaStringOpToken& r ) :
1981     FormulaByteToken( r ), maString( r.maString ) {}
1982
1983 FormulaToken* FormulaStringOpToken::Clone() const
1984 {
1985     return new FormulaStringOpToken(*this);
1986 }
1987
1988 const svl::SharedString & FormulaStringOpToken::GetString() const
1989 {
1990     return maString;
1991 }
1992
1993 void FormulaStringOpToken::SetString( const svl::SharedString& rStr )
1994 {
1995     maString = rStr;
1996 }
1997
1998 bool FormulaStringOpToken::operator==( const FormulaToken& r ) const
1999 {
2000     return FormulaByteToken::operator==( r ) && maString == r.GetString();
2001 }
2002
2003 sal_uInt16  FormulaIndexToken::GetIndex() const             { return nIndex; }
2004 void        FormulaIndexToken::SetIndex( sal_uInt16 n )     { nIndex = n; }
2005 sal_Int16   FormulaIndexToken::GetSheet() const             { return mnSheet; }
2006 void        FormulaIndexToken::SetSheet( sal_Int16 n )      { mnSheet = n; }
2007 bool FormulaIndexToken::operator==( const FormulaToken& r ) const
2008 {
2009     return FormulaToken::operator==( r ) && nIndex == r.GetIndex() &&
2010         mnSheet == r.GetSheet();
2011 }
2012 const OUString& FormulaExternalToken::GetExternal() const       { return aExternal; }
2013 bool FormulaExternalToken::operator==( const FormulaToken& r ) const
2014 {
2015     return FormulaByteToken::operator==( r ) && aExternal == r.GetExternal();
2016 }
2017
2018
2019 FormulaError      FormulaErrorToken::GetError() const             { return nError; }
2020 void            FormulaErrorToken::SetError( FormulaError nErr )  { nError = nErr; }
2021 bool FormulaErrorToken::operator==( const FormulaToken& r ) const
2022 {
2023     return FormulaToken::operator==( r ) &&
2024         nError == static_cast< const FormulaErrorToken & >(r).GetError();
2025 }
2026 double          FormulaMissingToken::GetDouble() const       { return 0.0; }
2027
2028 const svl::SharedString & FormulaMissingToken::GetString() const
2029 {
2030     return svl::SharedString::getEmptyString();
2031 }
2032
2033 bool FormulaMissingToken::operator==( const FormulaToken& r ) const
2034 {
2035     return FormulaToken::operator==( r );
2036 }
2037
2038
2039 bool FormulaUnknownToken::operator==( const FormulaToken& r ) const
2040 {
2041     return FormulaToken::operator==( r );
2042 }
2043
2044
2045 } // formula
2046
2047
2048 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */