sc/inc/interpretercontext.hxx

   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
  10 #pragma once
  11
  12 #include <array>
  13 #include <memory>
  14 #include <random>
  15 #include <vector>
  16 #include <i18nlangtag/mslangid.hxx>
  17 #include <svl/numformat.hxx>
  18 #include "types.hxx"
  19
  20 namespace formula
  21 {
  22 class FormulaTypedDoubleToken;
  23 }
  24
  25 #define TOKEN_CACHE_SIZE 8
  26
  27 class Color;
  28 class ScDocument;
  29 struct ScLookupCacheMap;
  30 class ScInterpreter;
  31
  32 // SetNumberFormat() is not thread-safe, so calls to it need to be delayed to the main thread.
  33 struct DelayedSetNumberFormat
  34 {
  35     SCCOL mCol;
  36     SCROW mRow;
  37     sal_uInt32 mnNumberFormat;
  38 };
  39
  40 class ScInterpreterContextPool;
  41
  42 struct ScInterpreterContext
  43 {
  44     const ScDocument* mpDoc;
  45     size_t mnTokenCachePos;
  46     std::vector<formula::FormulaTypedDoubleToken*> maTokens;
  47     std::vector<DelayedSetNumberFormat> maDelayedSetNumberFormat;
  48     std::unique_ptr<ScLookupCacheMap> mxScLookupCache; // cache for lookups like VLOOKUP and MATCH
  49     // Allocation cache for "aConditions" array in ScInterpreter::IterateParameterIfs()
  50     // This is populated/used only when formula-group threading is enabled.
  51     std::vector<sal_uInt8> maConditions;
  52     std::mt19937 aRNG;
  53     ScInterpreter* pInterpreter;
  54
  55     ScInterpreterContext(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
  56
  57     ScInterpreterContext() = delete;
  58
  59     ~ScInterpreterContext();
  60
  61     SvNumberFormatter* GetFormatTable() const
  62     {
  63         if (mpFormatter == nullptr)
  64             const_cast<ScInterpreterContext*>(this)->initFormatTable();
  65         return mpFormatter;
  66     }
  67
  68     SvNumFormatType NFGetType(sal_uInt32 nFIndex) const;
  69     const SvNumberformat* NFGetFormatEntry(sal_uInt32 nKey) const;
  70     sal_uInt32 NFGetFormatIndex(NfIndexTableOffset, LanguageType eLnge = LANGUAGE_DONTKNOW) const;
  71     bool NFIsTextFormat(sal_uInt32 nFIndex) const;
  72     sal_uInt32 NFGetTimeFormat(double fNumber, LanguageType eLnge, bool bForceDuration) const;
  73     const Date& NFGetNullDate() const;
  74     OUString NFGetFormatDecimalSep(sal_uInt32 nFormat) const;
  75     sal_uInt16 NFGetFormatPrecision(sal_uInt32 nFormat) const;
  76
  77     sal_uInt32 NFGetFormatForLanguageIfBuiltIn(sal_uInt32 nFormat, LanguageType eLnge) const;
  78
  79     bool NFIsNumberFormat(const OUString& sString, sal_uInt32& F_Index, double& fOutNumber,
  80                           SvNumInputOptions eInputOptions = SvNumInputOptions::NONE);
  81
  82     OUString NFGetInputLineString(const double& fOutNumber, sal_uInt32 nFIndex,
  83                                   bool bFiltering = false, bool bForceSystemLocale = false) const;
  84
  85     void NFGetOutputString(const double& fOutNumber, sal_uInt32 nFIndex, OUString& sOutString,
  86                            const Color** ppColor, bool bUseStarFormat = false) const;
  87
  88     void NFGetOutputString(const OUString& sString, sal_uInt32 nFIndex, OUString& sOutString,
  89                            const Color** ppColor, bool bUseStarFormat = false) const;
  90
  91     sal_uInt32 NFGetStandardFormat(SvNumFormatType eType, LanguageType eLnge = LANGUAGE_DONTKNOW);
  92     sal_uInt32 NFGetStandardFormat(sal_uInt32 nFIndex, SvNumFormatType eType, LanguageType eLnge);
  93
  94     bool NFGetPreviewString(const OUString& sFormatString, double fPreviewNumber,
  95                             OUString& sOutString, const Color** ppColor, LanguageType eLnge);
  96     bool NFGetPreviewString(const OUString& sFormatString, const OUString& sPreviewString,
  97                             OUString& sOutString, const Color** ppColor,
  98                             LanguageType eLnge = LANGUAGE_DONTKNOW);
  99     bool NFGetPreviewStringGuess(const OUString& sFormatString, double fPreviewNumber,
 100                                  OUString& sOutString, const Color** ppColor,
 101                                  LanguageType eLnge = LANGUAGE_DONTKNOW);
 102
 103     sal_uInt32 NFGetStandardIndex(LanguageType eLnge = LANGUAGE_DONTKNOW) const;
 104
 105     OUString NFGenerateFormat(sal_uInt32 nIndex, LanguageType eLnge = LANGUAGE_DONTKNOW,
 106                               bool bThousand = false, bool IsRed = false, sal_uInt16 nPrecision = 0,
 107                               sal_uInt16 nLeadingCnt = 1);
 108
 109     sal_uInt16 NFExpandTwoDigitYear(sal_uInt16 nYear) const;
 110
 111     OUString NFGetCalcCellReturn(sal_uInt32 nFormat) const;
 112
 113     void MergeDefaultFormatKeys(SvNumberFormatter& rFormatter) const;
 114
 115 private:
 116     friend class ScInterpreterContextPool;
 117     void ResetTokens();
 118     void SetDocAndFormatter(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
 119     void Cleanup();
 120     void ClearLookupCache(const ScDocument* pDoc);
 121     void initFormatTable();
 122     void prepFormatterForRoMode(SvNumberFormatter* pFormatter);
 123
 124     // During threaded calculation, where we don't need to add to the number
 125     // format data, we can access the numbering data with a RO unlocked view of
 126     // the NumberFormat's data and a throw-away object for currently used language
 127     // This is essentially an exploded view of mpFormatter
 128     std::unique_ptr<SvNFLanguageData> mxLanguageData;
 129     // FormatData can be driven read-only, but may want to cache some data,
 130     // in RO Mode we can cache per thread to mxAuxFormatKeyMap, and
 131     // discard or merge after threaded calculation is over
 132     std::unique_ptr<SvNFFormatData::DefaultFormatKeysMap> mxAuxFormatKeyMap;
 133
 134     const SvNFFormatData* mpFormatData;
 135     const NativeNumberWrapper* mpNatNum;
 136     SvNFEngine::Accessor maROPolicy;
 137
 138     // Some temp caches of the 4 most recent results from NumberFormatting
 139     // lookups.
 140     struct NFBuiltIn
 141     {
 142         sal_uInt64 nKey;
 143         sal_uInt32 nFormat;
 144         NFBuiltIn()
 145             : nKey(SAL_MAX_UINT64)
 146             , nFormat(SAL_MAX_UINT32)
 147         {
 148         }
 149     };
 150     // from format+lang to builtin format
 151     mutable std::array<NFBuiltIn, 4> maNFBuiltInCache;
 152     struct NFType
 153     {
 154         sal_uInt32 nKey;
 155         SvNumFormatType eType;
 156         NFType()
 157             : nKey(SAL_MAX_UINT32)
 158             , eType(SvNumFormatType::ALL)
 159         {
 160         }
 161     };
 162     // from format index to type
 163     mutable std::array<NFType, 4> maNFTypeCache;
 164
 165     // Formatter used when non-nthreaded calculation
 166     SvNumberFormatter* mpFormatter;
 167 };
 168
 169 class ScThreadedInterpreterContextGetterGuard;
 170 class ScInterpreterContextGetterGuard;
 171
 172 class ScInterpreterContextPool
 173 {
 174     friend class ScThreadedInterpreterContextGetterGuard;
 175     friend class ScInterpreterContextGetterGuard;
 176
 177     std::vector<std::unique_ptr<ScInterpreterContext>> maPool;
 178     size_t mnNextFree;
 179     bool mbThreaded;
 180
 181     ScInterpreterContextPool(bool bThreaded)
 182         : mnNextFree(0)
 183         , mbThreaded(bThreaded)
 184     {
 185     }
 186
 187     ~ScInterpreterContextPool() {}
 188
 189     static ScInterpreterContextPool aThreadedInterpreterPool;
 190     static ScInterpreterContextPool aNonThreadedInterpreterPool;
 191
 192     // API for threaded case
 193
 194     // Ensures nNumThreads elements in pool.
 195     void Init(size_t nNumThreads, const ScDocument& rDoc, SvNumberFormatter* pFormatter);
 196
 197     // Returns ScInterpreterContext* for thread index nThreadIdx
 198     ScInterpreterContext* GetInterpreterContextForThreadIdx(size_t nThreadIdx) const;
 199
 200     // API for non-threaded
 201
 202     // Ensures there is one unused element in the pool.
 203     void Init(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
 204
 205     // Returns ScInterpreterContext* for non-threaded use.
 206     ScInterpreterContext* GetInterpreterContext() const;
 207
 208     // Common API for threaded/non-threaded
 209
 210     // Cleans up the contexts prepared by call to immediately previous Init() and
 211     // marks them all as unused.
 212     void ReturnToPool();
 213
 214 public:
 215     // Only to be used to clear lookup cache in all pool elements
 216     static void ClearLookupCaches(const ScDocument* pDoc);
 217     // Called from ScModule dtor, drop all resources
 218     static void ModuleExiting();
 219 };
 220
 221 class ScThreadedInterpreterContextGetterGuard
 222 {
 223     ScInterpreterContextPool& rPool;
 224
 225 public:
 226     ScThreadedInterpreterContextGetterGuard(size_t nNumThreads, const ScDocument& rDoc,
 227                                             SvNumberFormatter* pFormatter);
 228     ~ScThreadedInterpreterContextGetterGuard();
 229
 230     // Returns ScInterpreterContext* for thread index nThreadIdx
 231     ScInterpreterContext* GetInterpreterContextForThreadIdx(size_t nThreadIdx) const;
 232 };
 233
 234 class ScInterpreterContextGetterGuard
 235 {
 236     ScInterpreterContextPool& rPool;
 237 #if !defined NDEBUG
 238     size_t nContextIdx;
 239 #endif
 240
 241 public:
 242     ScInterpreterContextGetterGuard(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
 243     ~ScInterpreterContextGetterGuard();
 244
 245     // Returns ScInterpreterContext* for non-threaded use.
 246     ScInterpreterContext* GetInterpreterContext() const;
 247 };
 248
 249 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */