sc/source/core/tool/interpretercontext.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 #include <interpretercontext.hxx>
  21 #include <svl/numformat.hxx>
  22 #include <svl/zforlist.hxx>
  23
  24 #include <document.hxx>
  25 #include <comphelper/random.hxx>
  26 #include <formula/token.hxx>
  27 #include <lookupcache.hxx>
  28 #include <rangecache.hxx>
  29 #include <algorithm>
  30
  31 ScInterpreterContextPool ScInterpreterContextPool::aThreadedInterpreterPool(true);
  32 ScInterpreterContextPool ScInterpreterContextPool::aNonThreadedInterpreterPool(false);
  33
  34 ScInterpreterContext::ScInterpreterContext(const ScDocument& rDoc, SvNumberFormatter* pFormatter)
  35     : mpDoc(&rDoc)
  36     , mnTokenCachePos(0)
  37     , maTokens(TOKEN_CACHE_SIZE, nullptr)
  38     // create a per-interpreter Random Number Generator, seeded from the global rng, so we don't have
  39     // to lock a mutex to generate a random number
  40     , aRNG(comphelper::rng::uniform_uint_distribution(0, std::numeric_limits<sal_uInt32>::max()))
  41     , pInterpreter(nullptr)
  42     , mpFormatter(pFormatter)
  43 {
  44     if (!pFormatter)
  45     {
  46         mpFormatData = nullptr;
  47         mpNatNum = nullptr;
  48     }
  49     else
  50         prepFormatterForRoMode(pFormatter);
  51 }
  52
  53 ScInterpreterContext::~ScInterpreterContext() { ResetTokens(); }
  54
  55 void ScInterpreterContext::ResetTokens()
  56 {
  57     for (auto p : maTokens)
  58         if (p)
  59             p->DecRef();
  60
  61     mnTokenCachePos = 0;
  62     std::fill(maTokens.begin(), maTokens.end(), nullptr);
  63 }
  64
  65 void ScInterpreterContext::SetDocAndFormatter(const ScDocument& rDoc, SvNumberFormatter* pFormatter)
  66 {
  67     if (mpDoc != &rDoc)
  68     {
  69         mxScLookupCache.reset();
  70         mpDoc = &rDoc;
  71     }
  72     if (mpFormatter != pFormatter)
  73     {
  74         mpFormatter = pFormatter;
  75
  76         // formatter has changed
  77         prepFormatterForRoMode(pFormatter);
  78
  79         // drop cache
  80         std::fill(maNFBuiltInCache.begin(), maNFBuiltInCache.end(), NFBuiltIn());
  81         std::fill(maNFTypeCache.begin(), maNFTypeCache.end(), NFType());
  82     }
  83 }
  84
  85 void ScInterpreterContext::prepFormatterForRoMode(SvNumberFormatter* pFormatter)
  86 {
  87     pFormatter->PrepForRoMode();
  88     mpFormatData = &pFormatter->GetROFormatData();
  89     mpNatNum = &pFormatter->GetNatNum();
  90     mxLanguageData.reset(new SvNFLanguageData(pFormatter->GetROLanguageData()));
  91     mxAuxFormatKeyMap.reset(new SvNFFormatData::DefaultFormatKeysMap);
  92     maROPolicy = SvNFEngine::GetROPolicy(*mpFormatData, *mxAuxFormatKeyMap);
  93 }
  94
  95 void ScInterpreterContext::initFormatTable()
  96 {
  97     mpFormatter = mpDoc->GetFormatTable(); // will assert if not main thread
  98     prepFormatterForRoMode(mpFormatter);
  99 }
 100
 101 void ScInterpreterContext::MergeDefaultFormatKeys(SvNumberFormatter& rFormatter) const
 102 {
 103     rFormatter.MergeDefaultFormatKeys(*mxAuxFormatKeyMap);
 104 }
 105
 106 void ScInterpreterContext::Cleanup()
 107 {
 108     // Do not disturb mxScLookupCache.
 109     maConditions.clear();
 110     maDelayedSetNumberFormat.clear();
 111     ResetTokens();
 112 }
 113
 114 void ScInterpreterContext::ClearLookupCache(const ScDocument* pDoc)
 115 {
 116     if (pDoc == mpDoc)
 117     {
 118         mxScLookupCache.reset();
 119         mxLanguageData.reset();
 120         mxAuxFormatKeyMap.reset();
 121         mpFormatter = nullptr;
 122         mpFormatData = nullptr;
 123         mpNatNum = nullptr;
 124     }
 125 }
 126
 127 SvNumFormatType ScInterpreterContext::NFGetType(sal_uInt32 nFIndex) const
 128 {
 129     if (!mpDoc->IsThreadedGroupCalcInProgress())
 130         return GetFormatTable()->GetType(nFIndex);
 131
 132     auto aFind = std::find_if(maNFTypeCache.begin(), maNFTypeCache.end(),
 133                               [nFIndex](const NFType& e) { return e.nKey == nFIndex; });
 134     if (aFind != maNFTypeCache.end())
 135         return aFind->eType;
 136
 137     SvNumFormatType eType = mpFormatData->GetType(nFIndex);
 138
 139     std::move_backward(maNFTypeCache.begin(),
 140                        std::next(maNFTypeCache.begin(), maNFTypeCache.size() - 1),
 141                        maNFTypeCache.end());
 142     maNFTypeCache[0].nKey = nFIndex;
 143     maNFTypeCache[0].eType = eType;
 144
 145     return eType;
 146 }
 147
 148 const SvNumberformat* ScInterpreterContext::NFGetFormatEntry(sal_uInt32 nKey) const
 149 {
 150     if (!mpDoc->IsThreadedGroupCalcInProgress())
 151         return GetFormatTable()->GetEntry(nKey);
 152     return mpFormatData->GetFormatEntry(nKey);
 153 }
 154
 155 bool ScInterpreterContext::NFIsTextFormat(sal_uInt32 nFIndex) const
 156 {
 157     if (!mpDoc->IsThreadedGroupCalcInProgress())
 158         return GetFormatTable()->IsTextFormat(nFIndex);
 159     return mpFormatData->IsTextFormat(nFIndex);
 160 }
 161
 162 const Date& ScInterpreterContext::NFGetNullDate() const
 163 {
 164     if (!mpDoc->IsThreadedGroupCalcInProgress())
 165         return GetFormatTable()->GetNullDate();
 166     return mxLanguageData->GetNullDate();
 167 }
 168
 169 sal_uInt32 ScInterpreterContext::NFGetTimeFormat(double fNumber, LanguageType eLnge,
 170                                                  bool bForceDuration) const
 171 {
 172     if (!mpDoc->IsThreadedGroupCalcInProgress())
 173         return GetFormatTable()->GetTimeFormat(fNumber, eLnge, bForceDuration);
 174     return SvNFEngine::GetTimeFormat(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy, fNumber,
 175                                      eLnge, bForceDuration);
 176 }
 177
 178 sal_uInt32 ScInterpreterContext::NFGetFormatIndex(NfIndexTableOffset nTabOff,
 179                                                   LanguageType eLnge) const
 180 {
 181     if (!mpDoc->IsThreadedGroupCalcInProgress())
 182         return GetFormatTable()->GetFormatIndex(nTabOff, eLnge);
 183     return SvNFEngine::GetFormatIndex(*mxLanguageData, maROPolicy, *mpNatNum, nTabOff, eLnge);
 184 }
 185 OUString ScInterpreterContext::NFGetFormatDecimalSep(sal_uInt32 nFormat) const
 186 {
 187     if (!mpDoc->IsThreadedGroupCalcInProgress())
 188         return GetFormatTable()->GetFormatDecimalSep(nFormat);
 189     return SvNFEngine::GetFormatDecimalSep(*mxLanguageData, *mpFormatData, nFormat);
 190 }
 191
 192 sal_uInt16 ScInterpreterContext::NFGetFormatPrecision(sal_uInt32 nFormat) const
 193 {
 194     if (!mpDoc->IsThreadedGroupCalcInProgress())
 195         return GetFormatTable()->GetFormatPrecision(nFormat);
 196     return SvNFEngine::GetFormatPrecision(*mxLanguageData, *mpFormatData, nFormat);
 197 }
 198
 199 sal_uInt32 ScInterpreterContext::NFGetFormatForLanguageIfBuiltIn(sal_uInt32 nFormat,
 200                                                                  LanguageType eLnge) const
 201 {
 202     if (!mpDoc->IsThreadedGroupCalcInProgress())
 203         return GetFormatTable()->GetFormatForLanguageIfBuiltIn(nFormat, eLnge);
 204
 205     sal_uInt64 nKey = (static_cast<sal_uInt64>(nFormat) << 32) | eLnge.get();
 206
 207     auto aFind = std::find_if(maNFBuiltInCache.begin(), maNFBuiltInCache.end(),
 208                               [nKey](const NFBuiltIn& e) { return e.nKey == nKey; });
 209     if (aFind != maNFBuiltInCache.end())
 210         return aFind->nFormat;
 211
 212     nFormat = SvNFEngine::GetFormatForLanguageIfBuiltIn(*mxLanguageData, *mpNatNum, maROPolicy,
 213                                                         nFormat, eLnge);
 214
 215     std::move_backward(maNFBuiltInCache.begin(),
 216                        std::next(maNFBuiltInCache.begin(), maNFBuiltInCache.size() - 1),
 217                        maNFBuiltInCache.end());
 218     maNFBuiltInCache[0].nKey = nKey;
 219     maNFBuiltInCache[0].nFormat = nFormat;
 220
 221     return nFormat;
 222 }
 223
 224 sal_uInt32 ScInterpreterContext::NFGetStandardFormat(SvNumFormatType eType, LanguageType eLnge)
 225 {
 226     if (!mpDoc->IsThreadedGroupCalcInProgress())
 227         return GetFormatTable()->GetStandardFormat(eType, eLnge);
 228     return SvNFEngine::GetStandardFormat(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 229                                          eType, eLnge);
 230 }
 231
 232 sal_uInt32 ScInterpreterContext::NFGetStandardFormat(sal_uInt32 nFIndex, SvNumFormatType eType,
 233                                                      LanguageType eLnge)
 234 {
 235     if (!mpDoc->IsThreadedGroupCalcInProgress())
 236         return GetFormatTable()->GetStandardFormat(nFIndex, eType, eLnge);
 237     return SvNFEngine::GetStandardFormat(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 238                                          nFIndex, eType, eLnge);
 239 }
 240
 241 OUString ScInterpreterContext::NFGetInputLineString(const double& fOutNumber, sal_uInt32 nFIndex,
 242                                                     bool bFiltering, bool bForceSystemLocale) const
 243 {
 244     if (!mpDoc->IsThreadedGroupCalcInProgress())
 245         return GetFormatTable()->GetInputLineString(fOutNumber, nFIndex, bFiltering,
 246                                                     bForceSystemLocale);
 247     return SvNFEngine::GetInputLineString(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 248                                           fOutNumber, nFIndex, bFiltering, bForceSystemLocale);
 249 }
 250 void ScInterpreterContext::NFGetOutputString(const double& fOutNumber, sal_uInt32 nFIndex,
 251                                              OUString& sOutString, const Color** ppColor,
 252                                              bool bUseStarFormat) const
 253 {
 254     if (!mpDoc->IsThreadedGroupCalcInProgress())
 255         return GetFormatTable()->GetOutputString(fOutNumber, nFIndex, sOutString, ppColor,
 256                                                  bUseStarFormat);
 257     return SvNFEngine::GetOutputString(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 258                                        fOutNumber, nFIndex, sOutString, ppColor, bUseStarFormat);
 259 }
 260
 261 void ScInterpreterContext::NFGetOutputString(const OUString& sString, sal_uInt32 nFIndex,
 262                                              OUString& sOutString, const Color** ppColor,
 263                                              bool bUseStarFormat) const
 264 {
 265     if (!mpDoc->IsThreadedGroupCalcInProgress())
 266         return GetFormatTable()->GetOutputString(sString, nFIndex, sOutString, ppColor,
 267                                                  bUseStarFormat);
 268     return SvNFEngine::GetOutputString(*mxLanguageData, *mpFormatData, sString, nFIndex, sOutString,
 269                                        ppColor, bUseStarFormat);
 270 }
 271
 272 sal_uInt32 ScInterpreterContext::NFGetStandardIndex(LanguageType eLnge) const
 273 {
 274     if (!mpDoc->IsThreadedGroupCalcInProgress())
 275         return GetFormatTable()->GetStandardIndex(eLnge);
 276     return SvNFEngine::GetStandardIndex(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 277                                         eLnge);
 278 }
 279
 280 bool ScInterpreterContext::NFGetPreviewString(const OUString& sFormatString, double fPreviewNumber,
 281                                               OUString& sOutString, const Color** ppColor,
 282                                               LanguageType eLnge)
 283 {
 284     if (!mpDoc->IsThreadedGroupCalcInProgress())
 285         return GetFormatTable()->GetPreviewString(sFormatString, fPreviewNumber, sOutString,
 286                                                   ppColor, eLnge);
 287     return SvNFEngine::GetPreviewString(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 288                                         sFormatString, fPreviewNumber, sOutString, ppColor, eLnge,
 289                                         false);
 290 }
 291 bool ScInterpreterContext::NFGetPreviewString(const OUString& sFormatString,
 292                                               const OUString& sPreviewString, OUString& sOutString,
 293                                               const Color** ppColor, LanguageType eLnge)
 294 {
 295     if (!mpDoc->IsThreadedGroupCalcInProgress())
 296         return GetFormatTable()->GetPreviewString(sFormatString, sPreviewString, sOutString,
 297                                                   ppColor, eLnge);
 298     return SvNFEngine::GetPreviewString(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 299                                         sFormatString, sPreviewString, sOutString, ppColor, eLnge);
 300 }
 301
 302 bool ScInterpreterContext::NFGetPreviewStringGuess(const OUString& sFormatString,
 303                                                    double fPreviewNumber, OUString& sOutString,
 304                                                    const Color** ppColor, LanguageType eLnge)
 305 {
 306     if (!mpDoc->IsThreadedGroupCalcInProgress())
 307         return GetFormatTable()->GetPreviewStringGuess(sFormatString, fPreviewNumber, sOutString,
 308                                                        ppColor, eLnge);
 309     return SvNFEngine::GetPreviewStringGuess(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 310                                              sFormatString, fPreviewNumber, sOutString, ppColor,
 311                                              eLnge);
 312 }
 313
 314 OUString ScInterpreterContext::NFGenerateFormat(sal_uInt32 nIndex, LanguageType eLnge,
 315                                                 bool bThousand, bool bIsRed, sal_uInt16 nPrecision,
 316                                                 sal_uInt16 nLeadingCnt)
 317 {
 318     if (!mpDoc->IsThreadedGroupCalcInProgress())
 319         return GetFormatTable()->GenerateFormat(nIndex, eLnge, bThousand, bIsRed, nPrecision,
 320                                                 nLeadingCnt);
 321     return SvNFEngine::GenerateFormat(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy, nIndex,
 322                                       eLnge, bThousand, bIsRed, nPrecision, nLeadingCnt);
 323 }
 324 OUString ScInterpreterContext::NFGetCalcCellReturn(sal_uInt32 nFormat) const
 325 {
 326     if (!mpDoc->IsThreadedGroupCalcInProgress())
 327         return GetFormatTable()->GetCalcCellReturn(nFormat);
 328     return mpFormatData->GetCalcCellReturn(nFormat);
 329 }
 330
 331 sal_uInt16 ScInterpreterContext::NFExpandTwoDigitYear(sal_uInt16 nYear) const
 332 {
 333     if (!mpDoc->IsThreadedGroupCalcInProgress())
 334         return GetFormatTable()->ExpandTwoDigitYear(nYear);
 335     return mxLanguageData->ExpandTwoDigitYear(nYear);
 336 }
 337
 338 bool ScInterpreterContext::NFIsNumberFormat(const OUString& sString, sal_uInt32& F_Index,
 339                                             double& fOutNumber, SvNumInputOptions eInputOptions)
 340 {
 341     if (!mpDoc->IsThreadedGroupCalcInProgress())
 342         return GetFormatTable()->IsNumberFormat(sString, F_Index, fOutNumber, eInputOptions);
 343     return SvNFEngine::IsNumberFormat(*mxLanguageData, *mpFormatData, *mpNatNum, maROPolicy,
 344                                       sString, F_Index, fOutNumber, eInputOptions);
 345 }
 346
 347 /* ScInterpreterContextPool */
 348
 349 // Threaded version
 350 void ScInterpreterContextPool::Init(size_t nNumThreads, const ScDocument& rDoc,
 351                                     SvNumberFormatter* pFormatter)
 352 {
 353     assert(mbThreaded);
 354     size_t nOldSize = maPool.size();
 355     maPool.resize(nNumThreads);
 356     for (size_t nIdx = 0; nIdx < nNumThreads; ++nIdx)
 357     {
 358         if (nIdx >= nOldSize)
 359             maPool[nIdx].reset(new ScInterpreterContext(rDoc, pFormatter));
 360         else
 361             maPool[nIdx]->SetDocAndFormatter(rDoc, pFormatter);
 362     }
 363 }
 364
 365 ScInterpreterContext*
 366 ScInterpreterContextPool::GetInterpreterContextForThreadIdx(size_t nThreadIdx) const
 367 {
 368     assert(mbThreaded);
 369     assert(nThreadIdx < maPool.size());
 370     return maPool[nThreadIdx].get();
 371 }
 372
 373 // Non-Threaded version
 374 void ScInterpreterContextPool::Init(const ScDocument& rDoc, SvNumberFormatter* pFormatter)
 375 {
 376     assert(!mbThreaded);
 377     assert(mnNextFree <= maPool.size());
 378     bool bCreateNew = (maPool.size() == mnNextFree);
 379     size_t nCurrIdx = mnNextFree;
 380     if (bCreateNew)
 381     {
 382         maPool.resize(maPool.size() + 1);
 383         maPool[nCurrIdx].reset(new ScInterpreterContext(rDoc, pFormatter));
 384     }
 385     else
 386         maPool[nCurrIdx]->SetDocAndFormatter(rDoc, pFormatter);
 387
 388     ++mnNextFree;
 389 }
 390
 391 ScInterpreterContext* ScInterpreterContextPool::GetInterpreterContext() const
 392 {
 393     assert(!mbThreaded);
 394     assert(mnNextFree && (mnNextFree <= maPool.size()));
 395     return maPool[mnNextFree - 1].get();
 396 }
 397
 398 void ScInterpreterContextPool::ReturnToPool()
 399 {
 400     if (mbThreaded)
 401     {
 402         for (size_t nIdx = 0; nIdx < maPool.size(); ++nIdx)
 403             maPool[nIdx]->Cleanup();
 404     }
 405     else
 406     {
 407         assert(mnNextFree && (mnNextFree <= maPool.size()));
 408         --mnNextFree;
 409         maPool[mnNextFree]->Cleanup();
 410     }
 411 }
 412
 413 // static
 414 void ScInterpreterContextPool::ClearLookupCaches(const ScDocument* pDoc)
 415 {
 416     for (auto& rPtr : aThreadedInterpreterPool.maPool)
 417         rPtr->ClearLookupCache(pDoc);
 418     for (auto& rPtr : aNonThreadedInterpreterPool.maPool)
 419         rPtr->ClearLookupCache(pDoc);
 420 }
 421
 422 // static
 423 void ScInterpreterContextPool::ModuleExiting()
 424 {
 425     for (auto& rPtr : aThreadedInterpreterPool.maPool)
 426         rPtr->mxLanguageData.reset();
 427     for (auto& rPtr : aNonThreadedInterpreterPool.maPool)
 428         rPtr->mxLanguageData.reset();
 429 }
 430
 431 /* ScThreadedInterpreterContextGetterGuard */
 432
 433 ScThreadedInterpreterContextGetterGuard::ScThreadedInterpreterContextGetterGuard(
 434     size_t nNumThreads, const ScDocument& rDoc, SvNumberFormatter* pFormatter)
 435     : rPool(ScInterpreterContextPool::aThreadedInterpreterPool)
 436 {
 437     rPool.Init(nNumThreads, rDoc, pFormatter);
 438 }
 439
 440 ScThreadedInterpreterContextGetterGuard::~ScThreadedInterpreterContextGetterGuard()
 441 {
 442     rPool.ReturnToPool();
 443 }
 444
 445 ScInterpreterContext*
 446 ScThreadedInterpreterContextGetterGuard::GetInterpreterContextForThreadIdx(size_t nThreadIdx) const
 447 {
 448     return rPool.GetInterpreterContextForThreadIdx(nThreadIdx);
 449 }
 450
 451 /* ScInterpreterContextGetterGuard */
 452
 453 ScInterpreterContextGetterGuard::ScInterpreterContextGetterGuard(const ScDocument& rDoc,
 454                                                                  SvNumberFormatter* pFormatter)
 455     : rPool(ScInterpreterContextPool::aNonThreadedInterpreterPool)
 456 #if !defined NDEBUG
 457     , nContextIdx(rPool.mnNextFree)
 458 #endif
 459 {
 460     rPool.Init(rDoc, pFormatter);
 461 }
 462
 463 ScInterpreterContextGetterGuard::~ScInterpreterContextGetterGuard()
 464 {
 465     assert(nContextIdx == (rPool.mnNextFree - 1));
 466     rPool.ReturnToPool();
 467 }
 468
 469 ScInterpreterContext* ScInterpreterContextGetterGuard::GetInterpreterContext() const
 470 {
 471     return rPool.GetInterpreterContext();
 472 }
 473
 474 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */