From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- sc/source/core/inc/addinhelpid.hxx | 45 + sc/source/core/inc/addinlis.hxx | 84 ++ sc/source/core/inc/adiasync.hxx | 77 ++ sc/source/core/inc/bcaslot.hxx | 396 +++++++++ sc/source/core/inc/cellkeytranslator.hxx | 83 ++ sc/source/core/inc/ddelink.hxx | 84 ++ sc/source/core/inc/doubleref.hxx | 178 ++++ sc/source/core/inc/formulagroupcl.hxx | 29 + sc/source/core/inc/grouptokenconverter.hxx | 38 + sc/source/core/inc/interpre.hxx | 1165 ++++++++++++++++++++++++++ sc/source/core/inc/jumpmatrix.hxx | 122 +++ sc/source/core/inc/parclass.hxx | 144 ++++ sc/source/core/inc/poolhelp.hxx | 65 ++ sc/source/core/inc/refupdat.hxx | 71 ++ sc/source/core/inc/scrdata.hxx | 37 + sc/source/core/inc/sharedstringpoolpurge.hxx | 48 ++ sc/source/core/inc/webservicelink.hxx | 49 ++ 17 files changed, 2715 insertions(+) create mode 100644 sc/source/core/inc/addinhelpid.hxx create mode 100644 sc/source/core/inc/addinlis.hxx create mode 100644 sc/source/core/inc/adiasync.hxx create mode 100644 sc/source/core/inc/bcaslot.hxx create mode 100644 sc/source/core/inc/cellkeytranslator.hxx create mode 100644 sc/source/core/inc/ddelink.hxx create mode 100644 sc/source/core/inc/doubleref.hxx create mode 100644 sc/source/core/inc/formulagroupcl.hxx create mode 100644 sc/source/core/inc/grouptokenconverter.hxx create mode 100644 sc/source/core/inc/interpre.hxx create mode 100644 sc/source/core/inc/jumpmatrix.hxx create mode 100644 sc/source/core/inc/parclass.hxx create mode 100644 sc/source/core/inc/poolhelp.hxx create mode 100644 sc/source/core/inc/refupdat.hxx create mode 100644 sc/source/core/inc/scrdata.hxx create mode 100644 sc/source/core/inc/sharedstringpoolpurge.hxx create mode 100644 sc/source/core/inc/webservicelink.hxx (limited to 'sc/source/core/inc') diff --git a/sc/source/core/inc/addinhelpid.hxx b/sc/source/core/inc/addinhelpid.hxx new file mode 100644 index 000000000..82967ecf9 --- /dev/null +++ b/sc/source/core/inc/addinhelpid.hxx @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include + +struct ScUnoAddInHelpId; + +/** Generates help IDs for standard Calc AddIns. */ +class ScUnoAddInHelpIdGenerator +{ +private: + const ScUnoAddInHelpId* pCurrHelpIds; /// Array of function names and help IDs. + sal_uInt32 nArrayCount; /// Count of array entries. + +public: + ScUnoAddInHelpIdGenerator() = delete; + ScUnoAddInHelpIdGenerator( std::u16string_view rServiceName ); + + /** Sets service name of the AddIn. Has to be done before requesting help IDs. */ + void SetServiceName( std::u16string_view rServiceName ); + + /** @return The help ID of the function with given built-in name or 0 if not found. */ + OString GetHelpId( const OUString& rFuncName ) const; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/addinlis.hxx b/sc/source/core/inc/addinlis.hxx new file mode 100644 index 000000000..ac3d2d64d --- /dev/null +++ b/sc/source/core/inc/addinlis.hxx @@ -0,0 +1,84 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include "adiasync.hxx" +#include +#include +#include + +namespace com::sun::star::sheet { class XVolatileResult; } +namespace rtl { template class Reference; } + +class ScDocument; + +class ScAddInListener final : public cppu::WeakImplHelper< + css::sheet::XResultListener, + css::lang::XServiceInfo >, + public SvtBroadcaster +{ +private: + css::uno::Reference xVolRes; + css::uno::Any aResult; + std::unique_ptr pDocs; // documents where this is used + + static ::std::vector> aAllListeners; + + // always allocated via CreateListener + ScAddInListener( css::uno::Reference const & xVR, + ScDocument* pD ); + +public: + virtual ~ScAddInListener() override; + + // create Listener and put it into global list + static ScAddInListener* CreateListener( + const css::uno::Reference& xVR, + ScDocument* pDoc ); + + static ScAddInListener* Get( const css::uno::Reference& xVR ); + + static void RemoveDocument( ScDocument* pDocument ); + + bool HasDocument( ScDocument* pDoc ) const + { return pDocs->find( pDoc ) != pDocs->end(); } + + void AddDocument( ScDocument* pDoc ) + { pDocs->insert( pDoc ); } + + const css::uno::Any& GetResult() const + { return aResult; } + + // XResultListener + virtual void SAL_CALL modified( const css::sheet::ResultEvent& aEvent ) override; + + // XEventListener + virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override; + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/adiasync.hxx b/sc/source/core/inc/adiasync.hxx new file mode 100644 index 000000000..b693f12a2 --- /dev/null +++ b/sc/source/core/inc/adiasync.hxx @@ -0,0 +1,77 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include +#include + +#include + +extern "C" { +void CALLTYPE ScAddInAsyncCallBack( double& nHandle, void* pData ); +} + +class ScDocument; +using ScAddInDocs = std::set; + +class ScAddInAsync final : public SvtBroadcaster +{ +private: + union + { + double nVal; // current value + OUString* pStr; + }; + std::unique_ptr pDocs; // List of using documents + LegacyFuncData* mpFuncData; // Pointer to data in collection + sal_uLong nHandle; // is casted from double to sal_uLong + ParamType meType; // result of type PTR_DOUBLE or PTR_STRING + bool bValid; // is value valid? + +public: + // cTor only if ScAddInAsync::Get fails. + // nIndex: Index from FunctionCollection + ScAddInAsync(sal_uLong nHandle, LegacyFuncData* pFuncData, ScDocument* pDoc); + virtual ~ScAddInAsync() override; + static ScAddInAsync* Get( sal_uLong nHandle ); + static void CallBack( sal_uLong nHandle, void* pData ); + static void RemoveDocument( ScDocument* pDocument ); + bool IsValid() const { return bValid; } + ParamType GetType() const { return meType; } + double GetValue() const { return nVal; } + const OUString& GetString() const { return *pStr; } + bool HasDocument( ScDocument* pDoc ) const + { return pDocs->find( pDoc ) != pDocs->end(); } + void AddDocument( ScDocument* pDoc ) { pDocs->insert( pDoc ); } + + // Comparators for PtrArrSort + bool operator< ( const ScAddInAsync& r ) const { return nHandle < r.nHandle; } +}; + +struct CompareScAddInAsync +{ + bool operator()( std::unique_ptr const& lhs, std::unique_ptr const& rhs ) const { return (*lhs)<(*rhs); } +}; +using ScAddInAsyncs = std::set, CompareScAddInAsync>; + +extern ScAddInAsyncs theAddInAsyncTbl; // in adiasync.cxx + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/bcaslot.hxx b/sc/source/core/inc/bcaslot.hxx new file mode 100644 index 000000000..c77a1173c --- /dev/null +++ b/sc/source/core/inc/bcaslot.hxx @@ -0,0 +1,396 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include +#include + +#include +#include +#include + +#include +#include + +namespace sc { class ColumnSpanSet; } +class ScHint; + +namespace sc { + +struct AreaListener +{ + ScRange maArea; + bool mbGroupListening; + SvtListener* mpListener; +}; + +} + +/** + Used in a Unique Associative Container. + */ + +class ScBroadcastArea +{ +private: + ScBroadcastArea* pUpdateChainNext; + SvtBroadcaster aBroadcaster; + ScRange aRange; + sal_uLong nRefCount; + + bool mbInUpdateChain:1; + bool mbGroupListening:1; + +public: + ScBroadcastArea(const ScBroadcastArea&) = delete; + const ScBroadcastArea& operator=(const ScBroadcastArea&) = delete; + + ScBroadcastArea( const ScRange& rRange ); + + SvtBroadcaster& GetBroadcaster() { return aBroadcaster; } + const SvtBroadcaster& GetBroadcaster() const { return aBroadcaster; } + void UpdateRange( const ScRange& rNewRange ) + { aRange = rNewRange; } + const ScRange& GetRange() const { return aRange; } + void IncRef() { ++nRefCount; } + sal_uLong DecRef() { return nRefCount ? --nRefCount : 0; } + sal_uLong GetRef() const { return nRefCount; } + ScBroadcastArea* GetUpdateChainNext() const { return pUpdateChainNext; } + void SetUpdateChainNext( ScBroadcastArea* p ) { pUpdateChainNext = p; } + bool IsInUpdateChain() const { return mbInUpdateChain; } + void SetInUpdateChain( bool b ) { mbInUpdateChain = b; } + + bool IsGroupListening() const { return mbGroupListening; } + void SetGroupListening( bool b ) { mbGroupListening = b; } + + /** Equalness of this or range. */ + inline bool operator==( const ScBroadcastArea & rArea ) const; +}; + +inline bool ScBroadcastArea::operator==( const ScBroadcastArea & rArea ) const +{ + return aRange == rArea.aRange && mbGroupListening == rArea.mbGroupListening; +} + +struct ScBroadcastAreaEntry +{ + ScBroadcastArea* mpArea; + mutable bool mbErasure; ///< TRUE if marked for erasure in this set + + ScBroadcastAreaEntry( ScBroadcastArea* p ) : mpArea( p), mbErasure( false) {} +}; + +struct ScBroadcastAreaHash +{ + size_t operator()( const ScBroadcastAreaEntry& rEntry ) const + { + return rEntry.mpArea->GetRange().hashArea() + static_cast(rEntry.mpArea->IsGroupListening()); + } +}; + +struct ScBroadcastAreaEqual +{ + bool operator()( const ScBroadcastAreaEntry& rEntry1, const ScBroadcastAreaEntry& rEntry2) const + { + return *rEntry1.mpArea == *rEntry2.mpArea; + } +}; + +typedef std::unordered_set< ScBroadcastAreaEntry, ScBroadcastAreaHash, ScBroadcastAreaEqual > ScBroadcastAreas; + +struct ScBroadcastAreaBulkHash +{ + size_t operator()( const ScBroadcastArea* p ) const + { + return reinterpret_cast(p); + } +}; + +struct ScBroadcastAreaBulkEqual +{ + bool operator()( const ScBroadcastArea* p1, const ScBroadcastArea* p2) const + { + return p1 == p2; + } +}; + +typedef std::unordered_set< const ScBroadcastArea*, ScBroadcastAreaBulkHash, + ScBroadcastAreaBulkEqual > ScBroadcastAreasBulk; + +class ScBroadcastAreaSlotMachine; + +/// Collection of BroadcastAreas +class ScBroadcastAreaSlot +{ +private: + ScBroadcastAreas aBroadcastAreaTbl; + mutable ScBroadcastArea aTmpSeekBroadcastArea; // for FindBroadcastArea() + ScDocument* pDoc; + ScBroadcastAreaSlotMachine* pBASM; + bool mbInBroadcastIteration; + + /** + * If true, the slot has at least one area broadcaster marked for removal. + * This flag is used only during broadcast iteration, to speed up + * iteration. Using this flag is cheaper than dereferencing each iterator + * and checking its own flag inside especially when no areas are marked + * for removal. + */ + bool mbHasErasedArea; + + ScBroadcastAreas::iterator FindBroadcastArea( const ScRange& rRange, bool bGroupListening ); + + /** + More hypothetical (memory would probably be doomed anyway) check + whether there would be an overflow when adding an area, setting the + proper state if so. + + @return HardRecalcState::ETERNAL if a HardRecalcState is effective and + area is not to be added. + */ + ScDocument::HardRecalcState CheckHardRecalcStateCondition() const; + + /** Finally erase all areas pushed as to-be-erased. */ + void FinallyEraseAreas(); + + static bool isMarkedErased( const ScBroadcastAreas::const_iterator& rIter ) + { + return rIter->mbErasure; + } + +public: + ScBroadcastAreaSlot( ScDocument* pDoc, + ScBroadcastAreaSlotMachine* pBASM ); + ~ScBroadcastAreaSlot(); + + /** + Only here new ScBroadcastArea objects are created, prevention of dupes. + + @param rpArea + If NULL, a new ScBroadcastArea is created and assigned ton the + reference if a matching area wasn't found. If a matching area was + found, that is assigned. In any case, the SvtListener is added to + the broadcaster. + + If not NULL then no listeners are started, only the area is + inserted and the reference count incremented. Effectively the same + as InsertListeningArea(), so use that instead. + + @return + true if rpArea passed was NULL and ScBroadcastArea is newly + created. + */ + bool StartListeningArea( + const ScRange& rRange, bool bGroupListening, SvtListener* pListener, ScBroadcastArea*& rpArea ); + + /** + Insert a ScBroadcastArea obtained via StartListeningArea() to + subsequent slots. + */ + void InsertListeningArea( ScBroadcastArea* pArea ); + + void EndListeningArea( + const ScRange& rRange, bool bGroupListening, SvtListener* pListener, ScBroadcastArea*& rpArea ); + + bool AreaBroadcast( const ScRange& rRange, SfxHintId nHint ); + bool AreaBroadcast( const ScHint& rHint ); + void DelBroadcastAreasInRange( const ScRange& rRange ); + void UpdateRemove( UpdateRefMode eUpdateRefMode, + const ScRange& rRange, + SCCOL nDx, SCROW nDy, SCTAB nDz ); + void UpdateRemoveArea( ScBroadcastArea* pArea ); + void UpdateInsert( ScBroadcastArea* pArea ); + + bool IsInBroadcastIteration() const { return mbInBroadcastIteration; } + + /** Erase an area from set and delete it if last reference, or if + mbInBroadcastIteration is set push it to the vector of to-be-erased + areas instead. + + Meant to be used internally and from ScBroadcastAreaSlotMachine only. + */ + void EraseArea( ScBroadcastAreas::iterator& rIter ); + + void GetAllListeners( + const ScRange& rRange, std::vector& rListeners, + sc::AreaOverlapType eType, sc::ListenerGroupType eGroup ); + +#if DEBUG_AREA_BROADCASTER + void Dump() const; +#endif +}; + +/** + BroadcastAreaSlots and their management, once per document. + */ + +class ScBroadcastAreaSlotMachine +{ +private: + typedef std::map BulkGroupAreasType; + + /** + Slot offset arrangement of columns and rows, once per sheet. + + +---+---+ + | 0 | 3 | + +---+---+ + | 1 | 4 | + +---+---+ + | 2 | 5 | + +---+---+ + */ + + class TableSlots + { + public: + TableSlots(SCSIZE nBcaSlots); + ~TableSlots(); + ScBroadcastAreaSlot** getSlots() { return ppSlots.get(); } + + private: + SCSIZE mnBcaSlots; + std::unique_ptr ppSlots; + + TableSlots( const TableSlots& ) = delete; + TableSlots& operator=( const TableSlots& ) = delete; + }; + + typedef ::std::map< SCTAB, std::unique_ptr > TableSlotsMap; + + typedef ::std::vector< ::std::pair< ScBroadcastAreaSlot*, ScBroadcastAreas::iterator > > AreasToBeErased; + +private: + struct ScSlotData + { + SCROW nStartRow; // first row of this segment + SCROW nStopRow; // first row of next segment + SCSIZE nSliceRow; // row slice size in this segment + SCSIZE nCumulatedRow; // cumulated slots of previous segments (previous rows) + SCROW nStartCol; // first column of this segment + SCROW nStopCol; // first column of next segment + SCSIZE nSliceCol; // column slice size in this segment + SCSIZE nCumulatedCol; // cumulated slots of previous segments (previous columns) + + ScSlotData( SCROW r1, SCROW r2, SCSIZE sr, SCSIZE cr, SCCOL c1, SCCOL c2, SCSIZE sc, SCSIZE cc ) + : nStartRow(r1) + , nStopRow(r2) + , nSliceRow(sr) + , nCumulatedRow(cr) + , nStartCol(c1) + , nStopCol(c2) + , nSliceCol(sc) + , nCumulatedCol(cc) {} + }; + typedef ::std::vector< ScSlotData > ScSlotDistribution; + ScSlotDistribution maSlotDistribution; + SCSIZE mnBcaSlotsCol; + SCSIZE mnBcaSlots; + ScBroadcastAreasBulk aBulkBroadcastAreas; + BulkGroupAreasType m_BulkGroupAreas; + TableSlotsMap aTableSlotsMap; + AreasToBeErased maAreasToBeErased; + std::unique_ptr pBCAlways; // for the RC_ALWAYS special range + ScDocument *pDoc; + ScBroadcastArea *pUpdateChain; + ScBroadcastArea *pEOUpdateChain; + sal_uInt32 nInBulkBroadcast; + + inline SCSIZE ComputeSlotOffset( const ScAddress& rAddress ) const; + void ComputeAreaPoints( const ScRange& rRange, + SCSIZE& nStart, SCSIZE& nEnd, + SCSIZE& nRowBreak ) const; +#ifdef DBG_UTIL + void DoChecks(); +#endif + +public: + ScBroadcastAreaSlotMachine( ScDocument* pDoc ); + ~ScBroadcastAreaSlotMachine(); + void StartListeningArea( + const ScRange& rRange, bool bGroupListening, SvtListener* pListener ); + + void EndListeningArea( + const ScRange& rRange, bool bGroupListening, SvtListener* pListener ); + + bool AreaBroadcast( const ScRange& rRange, SfxHintId nHint ); + bool AreaBroadcast( const ScHint& rHint ) const; + // return: at least one broadcast occurred + void DelBroadcastAreasInRange( const ScRange& rRange ); + void UpdateBroadcastAreas( UpdateRefMode eUpdateRefMode, + const ScRange& rRange, + SCCOL nDx, SCROW nDy, SCTAB nDz ); + void EnterBulkBroadcast(); + void LeaveBulkBroadcast( SfxHintId nHintId ); + bool InsertBulkArea( const ScBroadcastArea* p ); + + void InsertBulkGroupArea( ScBroadcastArea* pArea, const ScRange& rRange ); + void RemoveBulkGroupArea( ScBroadcastArea* pArea ); + bool BulkBroadcastGroupAreas( SfxHintId nHintId ); + + /// @return: how many removed + size_t RemoveBulkArea( const ScBroadcastArea* p ); + void SetUpdateChain( ScBroadcastArea* p ) { pUpdateChain = p; } + ScBroadcastArea* GetEOUpdateChain() const { return pEOUpdateChain; } + void SetEOUpdateChain( ScBroadcastArea* p ) { pEOUpdateChain = p; } + bool IsInBulkBroadcast() const { return nInBulkBroadcast > 0; } + + // only for ScBroadcastAreaSlot + void PushAreaToBeErased( ScBroadcastAreaSlot* pSlot, + ScBroadcastAreas::iterator& rIter ); + // only for ScBroadcastAreaSlot + void FinallyEraseAreas( ScBroadcastAreaSlot* pSlot ); + + std::vector GetAllListeners( + const ScRange& rRange, sc::AreaOverlapType eType, + sc::ListenerGroupType eGroup = sc::ListenerGroupType::Both ); + +#if DEBUG_AREA_BROADCASTER + void Dump() const; +#endif +}; + +class ScBulkBroadcast +{ + ScBroadcastAreaSlotMachine* pBASM; + SfxHintId mnHintId; + + ScBulkBroadcast(ScBulkBroadcast const &) = delete; + ScBulkBroadcast(ScBulkBroadcast &&) = delete; + ScBulkBroadcast & operator =(ScBulkBroadcast const &) = delete; + ScBulkBroadcast & operator =(ScBulkBroadcast &&) = delete; + +public: + explicit ScBulkBroadcast( ScBroadcastAreaSlotMachine* p, SfxHintId nHintId ) : + pBASM(p), + mnHintId(nHintId) + { + if (pBASM) + pBASM->EnterBulkBroadcast(); + } + ~ScBulkBroadcast() COVERITY_NOEXCEPT_FALSE + { + if (pBASM) + pBASM->LeaveBulkBroadcast( mnHintId ); + } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/cellkeytranslator.hxx b/sc/source/core/inc/cellkeytranslator.hxx new file mode 100644 index 000000000..1e42d1cf1 --- /dev/null +++ b/sc/source/core/inc/cellkeytranslator.hxx @@ -0,0 +1,83 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include +#include +#include +#include + +namespace com::sun::star::lang +{ +struct Locale; +} + +struct TransItem; + +struct ScCellKeyword +{ + const char* mpName; + OpCode meOpCode; + const css::lang::Locale& mrLocale; + + ScCellKeyword(const char* pName, OpCode eOpCode, const css::lang::Locale& rLocale); +}; + +typedef std::unordered_map> ScCellKeywordHashMap; + +/** Translate cell function keywords. + + This class provides a convenient way to translate a string keyword used as + a cell function argument. Since Calc's built-in cell functions don't + localize string keywords, this class is used mainly to deal with an Excel + document where string names may be localized. + + To use, simply call the + + ScCellKeywordTranslator::transKeyword(...) + + function. + + Note that when the locale and/or the opcode is specified, the function + tries to find a string with matching locale and/or opcode. But when it + fails to find one that satisfies the specified locale and/or opcode, it + returns a translated string with non-matching locale and/or opcode if + available. */ +class ScCellKeywordTranslator +{ +public: + static void transKeyword(OUString& rName, const css::lang::Locale* pLocale, OpCode eOpCode); + ~ScCellKeywordTranslator(); + +private: + ScCellKeywordTranslator(); + + void init(); + void addToMap(const OUString& rKey, const char* pName, const css::lang::Locale& rLocale, + OpCode eOpCode); + void addToMap(const TransItem* pItems, const css::lang::Locale& rLocale); + + static ::std::unique_ptr spInstance; + ScCellKeywordHashMap maStringNameMap; + ::utl::TransliterationWrapper maTransWrapper; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/ddelink.hxx b/sc/source/core/inc/ddelink.hxx new file mode 100644 index 000000000..6baa7cee4 --- /dev/null +++ b/sc/source/core/inc/ddelink.hxx @@ -0,0 +1,84 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include +#include + +namespace com::sun::star::uno { class Any; } + +class ScDocument; +class ScMultipleReadHeader; +class ScMultipleWriteHeader; +class SvStream; + +class ScDdeLink final : public ::sfx2::SvBaseLink, public SvtBroadcaster +{ +private: +static bool bIsInUpdate; + + ScDocument& rDoc; + + OUString aAppl; // connection/ link data + OUString aTopic; + OUString aItem; + sal_uInt8 nMode; // number format mode + + bool bNeedUpdate; // is set, if update was not possible + + ScMatrixRef pResult; + +public: + + ScDdeLink( ScDocument& rD, + const OUString& rA, const OUString& rT, const OUString& rI, + sal_uInt8 nM ); + ScDdeLink( ScDocument& rD, SvStream& rStream, ScMultipleReadHeader& rHdr ); + ScDdeLink( ScDocument& rD, const ScDdeLink& rOther ); + virtual ~ScDdeLink() override; + + void Store( SvStream& rStream, ScMultipleWriteHeader& rHdr ) const; + + // SvBaseLink override: + virtual ::sfx2::SvBaseLink::UpdateResult DataChanged( + const OUString& rMimeType, const css::uno::Any & rValue ) override; + + // SvtBroadcaster override: + virtual void ListenersGone() override; + + // for interpreter: + + const ScMatrix* GetResult() const; + void SetResult( const ScMatrixRef& pRes ); + + const OUString& GetAppl() const { return aAppl; } + const OUString& GetTopic() const { return aTopic; } + const OUString& GetItem() const { return aItem; } + sal_uInt8 GetMode() const { return nMode; } + + void TryUpdate(); + + bool NeedsUpdate() const { return bNeedUpdate; } + + static bool IsInUpdate() { return bIsInUpdate; } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/doubleref.hxx b/sc/source/core/inc/doubleref.hxx new file mode 100644 index 000000000..b8cb084e7 --- /dev/null +++ b/sc/source/core/inc/doubleref.hxx @@ -0,0 +1,178 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +#include + +#include +#include + +class ScDocument; +struct ScDBQueryParamBase; +struct ScQueryParamBase; +enum class FormulaError : sal_uInt16; + +/** + * Base class for abstracting range data backends for database functions. + */ +class ScDBRangeBase +{ +public: + ScDBRangeBase() = delete; + + virtual ~ScDBRangeBase() = 0; + + bool fillQueryEntries(ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef) const; + + virtual SCCOL getColSize() const = 0; + virtual SCROW getRowSize() const = 0; + virtual SCSIZE getVisibleDataCellCount() const = 0; + + /** + * Get a string value of a specified cell position. Note that the + * position of the upper left cell of the range is always (0, 0) even if + * the reference type is of internal range. + * + * @param nCol column position (0 to column size-1) + * @param nRow row position (0 to row size-1) + */ + virtual OUString getString(SCCOL nCol, SCROW nRow) const = 0; + + virtual SCCOL getFirstFieldColumn() const = 0; + + /** + * Get a 0-based column index that corresponds with the passed field + * index. Note that the field index passed as the 1st parameter is + * 1-based. + * + * @param nIndex 1-based field index. + * + * @return 0-based column index + */ + virtual SCCOL findFieldColumn(SCCOL nIndex) const = 0; + virtual SCCOL findFieldColumn(const OUString& rStr, FormulaError* pErr = nullptr) const = 0; + virtual std::unique_ptr + createQueryParam(const ScDBRangeBase* pQueryRef) const = 0; + virtual bool isRangeEqual(const ScRange& rRange) const = 0; + +protected: + ScDBRangeBase(ScDocument* pDoc); + ScDocument* getDoc() const { return mpDoc; } + + /** + * Populate query options that are always the same for all database + * queries. + */ + static void fillQueryOptions(ScQueryParamBase* pParam); + +private: + ScDocument* mpDoc; +}; + +class ScDBInternalRange final : public ScDBRangeBase +{ +public: + explicit ScDBInternalRange(ScDocument* pDoc, const ScRange& rRange); + virtual ~ScDBInternalRange() override; + + const ScRange& getRange() const { return maRange; } + + virtual SCCOL getColSize() const override; + virtual SCROW getRowSize() const override; + virtual SCSIZE getVisibleDataCellCount() const override; + + /** + * Get a string value of a specified cell position. Note that the + * position of the upper left cell of the range is always (0, 0) even if + * the reference type is of internal range. + * + * @param nCol column position (0 to column size-1) + * @param nRow row position (0 to row size-1) + */ + virtual OUString getString(SCCOL nCol, SCROW nRow) const override; + + virtual SCCOL getFirstFieldColumn() const override; + /** + * Get a 0-based column index that corresponds with the passed field + * index. Note that the field index passed as the 1st parameter is + * 1-based. + * + * @param nIndex 1-based field index. + * + * @return 0-based column index + */ + virtual SCCOL findFieldColumn(SCCOL nIndex) const override; + virtual SCCOL findFieldColumn(const OUString& rStr, + FormulaError* pErr = nullptr) const override; + virtual std::unique_ptr + createQueryParam(const ScDBRangeBase* pQueryRef) const override; + virtual bool isRangeEqual(const ScRange& rRange) const override; + +private: + ScRange maRange; +}; + +class ScDBExternalRange final : public ScDBRangeBase +{ +public: + explicit ScDBExternalRange(ScDocument* pDoc, const ScMatrixRef& pMat); + virtual ~ScDBExternalRange() override; + + virtual SCCOL getColSize() const override; + virtual SCROW getRowSize() const override; + virtual SCSIZE getVisibleDataCellCount() const override; + + /** + * Get a string value of a specified cell position. Note that the + * position of the upper left cell of the range is always (0, 0) even if + * the reference type is of internal range. + * + * @param nCol column position (0 to column size-1) + * @param nRow row position (0 to row size-1) + */ + virtual OUString getString(SCCOL nCol, SCROW nRow) const override; + + virtual SCCOL getFirstFieldColumn() const override; + + /** + * Get a 0-based column index that corresponds with the passed field + * index. Note that the field index passed as the 1st parameter is + * 1-based. + * + * @param nIndex 1-based field index. + * + * @return 0-based column index + */ + virtual SCCOL findFieldColumn(SCCOL nIndex) const override; + virtual SCCOL findFieldColumn(const OUString& rStr, + FormulaError* pErr = nullptr) const override; + virtual std::unique_ptr + createQueryParam(const ScDBRangeBase* pQueryRef) const override; + virtual bool isRangeEqual(const ScRange& rRange) const override; + +private: + const ScMatrixRef mpMatrix; + SCCOL mnCols; + SCROW mnRows; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/formulagroupcl.hxx b/sc/source/core/inc/formulagroupcl.hxx new file mode 100644 index 000000000..586b21f4c --- /dev/null +++ b/sc/source/core/inc/formulagroupcl.hxx @@ -0,0 +1,29 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#pragma once + +#include + +namespace sc::opencl { + +class FormulaGroupInterpreterOpenCL final : public FormulaGroupInterpreter +{ +public: + FormulaGroupInterpreterOpenCL(); + virtual ~FormulaGroupInterpreterOpenCL() override; + + virtual ScMatrixRef inverseMatrix( const ScMatrix& rMat ) override; + virtual bool interpret( ScDocument& rDoc, const ScAddress& rTopPos, + ScFormulaCellGroupRef& xGroup, ScTokenArray& rCode ) override; +}; + +} // namespace sc::opencl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/grouptokenconverter.hxx b/sc/source/core/inc/grouptokenconverter.hxx new file mode 100644 index 000000000..0d2f02227 --- /dev/null +++ b/sc/source/core/inc/grouptokenconverter.hxx @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#pragma once + +#include +#include + +class ScDocument; +class ScFormulaCell; +class ScTokenArray; +namespace sc { struct FormulaGroupContext; } + +class ScGroupTokenConverter +{ + ScTokenArray& mrGroupTokens; + ScDocument& mrDoc; + std::shared_ptr mxFormulaGroupContext; + const ScFormulaCell& mrCell; + const ScAddress& mrPos; + + bool isSelfReferenceRelative(const ScAddress& rRefPos, SCROW nRelRow); + bool isSelfReferenceAbsolute(const ScAddress& rRefPos); + SCROW trimLength(SCTAB nTab, SCCOL nCol1, SCCOL nCol2, SCROW nRow, SCROW nRowLen); + +public: + ScGroupTokenConverter(ScTokenArray& rGroupTokens, ScDocument& rDoc, const ScFormulaCell& rCell, const ScAddress& rPos); + + bool convert( const ScTokenArray& rCode, sc::FormulaLogger::GroupScope& rScope ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/interpre.hxx b/sc/source/core/inc/interpre.hxx new file mode 100644 index 000000000..c1fc5f458 --- /dev/null +++ b/sc/source/core/inc/interpre.hxx @@ -0,0 +1,1165 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "parclass.hxx" + +#include +#include +#include +#include +#include + +namespace sfx2 { class LinkManager; } + +class ScDocument; +class SbxVariable; +class ScFormulaCell; +class ScDBRangeBase; +struct ScQueryParam; +struct ScDBQueryParamBase; +struct ScQueryEntry; + +struct ScSingleRefData; +struct ScComplexRefData; +struct ScInterpreterContext; + +class ScJumpMatrix; +struct ScRefCellValue; + +namespace sc { + +struct CompareOptions; + +struct ParamIfsResult +{ + KahanSum mfSum = 0.0; + double mfCount = 0.0; + double mfMin = std::numeric_limits::max(); + double mfMax = std::numeric_limits::lowest(); +}; + +template +inline std::basic_ostream & operator <<(std::basic_ostream & stream, const ParamIfsResult& rRes) +{ + stream << "{" << + "sum=" << rRes.mfSum.get() << "," << + "count=" << rRes.mfCount << "," << + "min=" << rRes.mfMin << "," << + "max=" << rRes.mfMax << "," << + "}"; + + return stream; +} + +} + +namespace svl { + +class SharedStringPool; + +} + +/// Arbitrary 256MB result string length limit. +constexpr sal_Int32 kScInterpreterMaxStrLen = SAL_MAX_INT32 / 8; + +#define MAXSTACK (4096 / sizeof(formula::FormulaToken*)) + +class ScTokenStack +{ +public: + const formula::FormulaToken* pPointer[ MAXSTACK ]; +}; + +enum ScIterFunc { + ifSUM, // Add up + ifSUMSQ, // Sums of squares + ifPRODUCT, // Product + ifAVERAGE, // Average + ifCOUNT, // Count Values + ifCOUNT2, // Count Values (not empty) + ifMIN, // Minimum + ifMAX // Maximum +}; + +enum ScIterFuncIf +{ + ifSUMIF, // Conditional sum + ifAVERAGEIF // Conditional average +}; + +enum ScETSType +{ + etsAdd, + etsMult, + etsSeason, + etsPIAdd, + etsPIMult, + etsStatAdd, + etsStatMult +}; + +struct FormulaTokenRef_less +{ + bool operator () ( const formula::FormulaConstTokenRef& r1, const formula::FormulaConstTokenRef& r2 ) const + { return r1.get() < r2.get(); } +}; +typedef ::std::map< const formula::FormulaConstTokenRef, formula::FormulaConstTokenRef, FormulaTokenRef_less> ScTokenMatrixMap; + +class ScInterpreter +{ + // distribution function objects need the GetxxxDist methods + friend class ScGammaDistFunction; + friend class ScBetaDistFunction; + friend class ScTDistFunction; + friend class ScFDistFunction; + friend class ScChiDistFunction; + friend class ScChiSqDistFunction; + +public: + static void SetGlobalConfig(const ScCalcConfig& rConfig); + static const ScCalcConfig& GetGlobalConfig(); + + static void GlobalExit(); // called by ScGlobal::Clear() + + /** Detect if string should be used as regular expression or wildcard + expression or literal string. + */ + static utl::SearchParam::SearchType DetectSearchType(std::u16string_view rStr, const ScDocument& rDoc ); + + /// Fail safe division, returning a FormulaError::DivisionByZero coded into a double + /// if denominator is 0.0 + static inline double div( const double& fNumerator, const double& fDenominator ); + + ScMatrixRef GetNewMat(SCSIZE nC, SCSIZE nR, bool bEmpty = false); + + ScMatrixRef GetNewMat(SCSIZE nC, SCSIZE nR, const std::vector& rValues); + + enum VolatileType { + VOLATILE, + VOLATILE_MACRO, + NOT_VOLATILE + }; + + VolatileType GetVolatileType() const { return meVolatileType;} + +private: + static ScCalcConfig& GetOrCreateGlobalConfig(); + static ScCalcConfig *mpGlobalConfig; + + static thread_local std::unique_ptr pGlobalStack; + static thread_local bool bGlobalStackInUse; + + ScCalcConfig maCalcConfig; + formula::FormulaTokenIterator aCode; + ScAddress aPos; + ScTokenArray* pArr; + ScInterpreterContext& mrContext; + ScDocument& mrDoc; + sfx2::LinkManager* mpLinkManager; + svl::SharedStringPool& mrStrPool; + formula::FormulaConstTokenRef xResult; + ScJumpMatrix* pJumpMatrix; // currently active array condition, if any + ScTokenMatrixMap maTokenMatrixMap; // map FormulaToken* to formula::FormulaTokenRef if in array condition + ScFormulaCell* pMyFormulaCell; // the cell of this formula expression + SvNumberFormatter* pFormatter; + + const formula::FormulaToken* pCur; // current token + ScTokenStack* pStackObj; // contains the stacks + const formula::FormulaToken ** pStack; // the current stack + FormulaError nGlobalError; // global (local to this formula expression) error + sal_uInt16 sp; // stack pointer + sal_uInt16 maxsp; // the maximal used stack pointer + sal_uInt32 nFuncFmtIndex; // NumberFormatIndex of a function + sal_uInt32 nCurFmtIndex; // current NumberFormatIndex + sal_uInt32 nRetFmtIndex; // NumberFormatIndex of an expression, if any + SvNumFormatType nFuncFmtType; // NumberFormatType of a function + SvNumFormatType nCurFmtType; // current NumberFormatType + SvNumFormatType nRetFmtType; // NumberFormatType of an expression + FormulaError mnStringNoValueError; // the error set in ConvertStringToValue() if no value + SubtotalFlags mnSubTotalFlags; // flags for subtotal and aggregate functions + sal_uInt8 cPar; // current count of parameters + bool bCalcAsShown; // precision as shown + bool bMatrixFormula; // formula cell is a matrix formula + + VolatileType meVolatileType; + + void MakeMatNew(ScMatrixRef& rMat, SCSIZE nC, SCSIZE nR); + + /// Merge global and document specific settings. + void MergeCalcConfig(); + + // nMust <= nAct <= nMax ? ok : PushError + inline bool MustHaveParamCount( short nAct, short nMust ); + inline bool MustHaveParamCount( short nAct, short nMust, short nMax ); + inline bool MustHaveParamCountMin( short nAct, short nMin ); + inline bool MustHaveParamCountMinWithStackCheck( short nAct, short nMin ); + void PushParameterExpected(); + void PushIllegalParameter(); + void PushIllegalArgument(); + void PushNoValue(); + void PushNA(); + + // Functions for accessing a document + + void ReplaceCell( ScAddress& ); // for TableOp + bool IsTableOpInRange( const ScRange& ); + sal_uInt32 GetCellNumberFormat( const ScAddress& rPos, ScRefCellValue& rCell ); + double ConvertStringToValue( const OUString& ); +public: + static double ScGetGCD(double fx, double fy); + /** For matrix back calls into the current interpreter. + Uses rError instead of nGlobalError and rCurFmtType instead of nCurFmtType. */ + double ConvertStringToValue( const OUString&, FormulaError& rError, SvNumFormatType& rCurFmtType ); +private: + double GetCellValue( const ScAddress&, ScRefCellValue& rCell ); + double GetCellValueOrZero( const ScAddress&, ScRefCellValue& rCell ); + double GetValueCellValue( const ScAddress&, double fOrig ); + void GetCellString( svl::SharedString& rStr, ScRefCellValue& rCell ); + static FormulaError GetCellErrCode( const ScRefCellValue& rCell ); + + bool CreateDoubleArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8* pCellArr); + bool CreateStringArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8* pCellArr); + bool CreateCellArr(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2, sal_uInt8* pCellArr); + + // Stack operations + + /** Does substitute with formula::FormulaErrorToken in case nGlobalError is set and the token + passed is not formula::FormulaErrorToken. + Increments RefCount of the original token if not substituted. */ + void Push( const formula::FormulaToken& r ); + + /** Does not substitute with formula::FormulaErrorToken in case nGlobalError is set. + Used to push RPN tokens or from within Push() or tokens that are already + explicit formula::FormulaErrorToken. Increments RefCount. */ + void PushWithoutError( const formula::FormulaToken& r ); + + /** Does substitute with formula::FormulaErrorToken in case nGlobalError is set and the token + passed is not formula::FormulaErrorToken. + Increments RefCount of the original token if not substituted. + ATTENTION! The token had to be allocated with `new' and must not be used + after this call if no RefCount was set because possibly it gets immediately + deleted in case of a FormulaError::StackOverflow or if substituted with formula::FormulaErrorToken! */ + void PushTempToken( formula::FormulaToken* ); + + /** Pushes the token or substitutes with formula::FormulaErrorToken in case + nGlobalError is set and the token passed is not formula::FormulaErrorToken. + Increments RefCount of the original token if not substituted. */ + void PushTokenRef( const formula::FormulaConstTokenRef& ); + + /** Does not substitute with formula::FormulaErrorToken in case nGlobalError is set. + Used to push tokens from within PushTempToken() or tokens that are already + explicit formula::FormulaErrorToken. Increments RefCount. + ATTENTION! The token had to be allocated with `new' and must not be used + after this call if no RefCount was set because possibly it gets immediately + decremented again and thus deleted in case of a FormulaError::StackOverflow! */ + void PushTempTokenWithoutError( const formula::FormulaToken* ); + + /** If nGlobalError is set push formula::FormulaErrorToken. + If nGlobalError is not set do nothing. + Used in PushTempToken() and alike to simplify handling. + @return: if nGlobalError. */ + bool IfErrorPushError() + { + if (nGlobalError != FormulaError::NONE) + { + PushTempTokenWithoutError( new formula::FormulaErrorToken( nGlobalError)); + return true; + } + return false; + } + + /** Obtain cell result / content from address and push as temp token. + + @param bDisplayEmptyAsString + is passed to ScEmptyCell in case of an empty cell result. + + @param pRetTypeExpr + @param pRetIndexExpr + Obtain number format and type if _both_, type and index pointer, + are not NULL. + + @param bFinalResult + If TRUE, only a standard FormulaDoubleToken is pushed. + If FALSE, PushDouble() is used that may push either a + FormulaDoubleToken or a FormulaTypedDoubleToken. + */ + void PushCellResultToken( bool bDisplayEmptyAsString, const ScAddress & rAddress, + SvNumFormatType * pRetTypeExpr, sal_uInt32 * pRetIndexExpr, bool bFinalResult = false ); + + formula::FormulaConstTokenRef PopToken(); + void Pop(); + void PopError(); + double PopDouble(); + svl::SharedString PopString(); + void ValidateRef( const ScSingleRefData & rRef ); + void ValidateRef( const ScComplexRefData & rRef ); + void ValidateRef( const ScRefList & rRefList ); + void SingleRefToVars( const ScSingleRefData & rRef, SCCOL & rCol, SCROW & rRow, SCTAB & rTab ); + void PopSingleRef( ScAddress& ); + void PopSingleRef(SCCOL& rCol, SCROW &rRow, SCTAB& rTab); + void DoubleRefToRange( const ScComplexRefData&, ScRange&, bool bDontCheckForTableOp = false ); + /** If formula::StackVar formula::svDoubleRef pop ScDoubleRefToken and return values of + ScComplexRefData. + Else if StackVar svRefList return values of the ScComplexRefData where + rRefInList is pointing to. rRefInList is incremented. If rRefInList was the + last element in list pop ScRefListToken and set rRefInList to 0, else + rParam is incremented (!) to allow usage as in + while(nParamCount--) PopDoubleRef(aRange,nParamCount,nRefInList); + */ + void PopDoubleRef( ScRange & rRange, short & rParam, size_t & rRefInList ); + void PopDoubleRef( ScRange&, bool bDontCheckForTableOp = false ); + void DoubleRefToVars( const formula::FormulaToken* p, + SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1, + SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2 ); + ScDBRangeBase* PopDBDoubleRef(); + void PopDoubleRef(SCCOL& rCol1, SCROW &rRow1, SCTAB& rTab1, + SCCOL& rCol2, SCROW &rRow2, SCTAB& rTab2 ); + // peek double ref data + const ScComplexRefData* GetStackDoubleRef(size_t rRefInList = 0); + + void PopExternalSingleRef(sal_uInt16& rFileId, OUString& rTabName, ScSingleRefData& rRef); + + /** Guarantees that nGlobalError is set if rToken could not be obtained. */ + void PopExternalSingleRef(ScExternalRefCache::TokenRef& rToken, ScExternalRefCache::CellFormat* pFmt = nullptr); + + /** Guarantees that nGlobalError is set if rToken could not be obtained. */ + void PopExternalSingleRef(sal_uInt16& rFileId, OUString& rTabName, ScSingleRefData& rRef, + ScExternalRefCache::TokenRef& rToken, ScExternalRefCache::CellFormat* pFmt = nullptr); + + void PopExternalDoubleRef(sal_uInt16& rFileId, OUString& rTabName, ScComplexRefData& rRef); + void PopExternalDoubleRef(ScExternalRefCache::TokenArrayRef& rArray); + void PopExternalDoubleRef(ScMatrixRef& rMat); + void GetExternalDoubleRef(sal_uInt16 nFileId, const OUString& rTabName, const ScComplexRefData& aData, ScExternalRefCache::TokenArrayRef& rArray); + bool PopDoubleRefOrSingleRef( ScAddress& rAdr ); + void PopDoubleRefPushMatrix(); + void PopRefListPushMatrixOrRef(); + // If MatrixFormula: convert svDoubleRef to svMatrix, create JumpMatrix. + // Else convert area reference parameters marked as ForceArray to array. + // Returns true if JumpMatrix created. + bool ConvertMatrixParameters(); + // If MatrixFormula: ConvertMatrixJumpConditionToMatrix() + inline void MatrixJumpConditionToMatrix(); + // For MatrixFormula (preconditions already checked by + // MatrixJumpConditionToMatrix()): convert svDoubleRef to svMatrix, or if + // JumpMatrix currently in effect convert also other types to svMatrix so + // another JumpMatrix will be created by jump commands. + void ConvertMatrixJumpConditionToMatrix(); + // If MatrixFormula or ForceArray: ConvertMatrixParameters() + inline bool MatrixParameterConversion(); + // If MatrixFormula or ForceArray. Can be used within spreadsheet functions + // that do not depend on the formula cell's matrix size, for which only + // bMatrixFormula can be used. + inline bool IsInArrayContext() const; + ScMatrixRef PopMatrix(); + sc::RangeMatrix PopRangeMatrix(); + void QueryMatrixType(const ScMatrixRef& xMat, SvNumFormatType& rRetTypeExpr, sal_uInt32& rRetIndexExpr); + + formula::FormulaToken* CreateFormulaDoubleToken( double fVal, SvNumFormatType nFmt = SvNumFormatType::NUMBER ); + formula::FormulaToken* CreateDoubleOrTypedToken( double fVal ); + + void PushDouble(double nVal); + void PushInt( int nVal ); + void PushStringBuffer( const sal_Unicode* pString ); + void PushString( const OUString& rStr ); + void PushString( const svl::SharedString& rString ); + void PushSingleRef(SCCOL nCol, SCROW nRow, SCTAB nTab); + void PushDoubleRef(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2); + void PushExternalSingleRef(sal_uInt16 nFileId, const OUString& rTabName, + SCCOL nCol, SCROW nRow, SCTAB nTab); + void PushExternalDoubleRef(sal_uInt16 nFileId, const OUString& rTabName, + SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2); + void PushSingleRef( const ScRefAddress& rRef ); + void PushDoubleRef( const ScRefAddress& rRef1, const ScRefAddress& rRef2 ); + void PushMatrix( const sc::RangeMatrix& rMat ); + void PushMatrix(const ScMatrixRef& pMat); + void PushError( FormulaError nError ); + /// Raw stack type without default replacements. + formula::StackVar GetRawStackType(); + /// Stack type with replacement of defaults, e.g. svMissing and formula::svEmptyCell will result in formula::svDouble. + formula::StackVar GetStackType(); + // peek StackType of Parameter, Parameter 1 == TOS, 2 == TOS-1, ... + formula::StackVar GetStackType( sal_uInt8 nParam ); + sal_uInt8 GetByte() const { return cPar; } + // reverse order of stack + void ReverseStack( sal_uInt8 nParamCount ); + // generates a position-dependent SingleRef out of a DoubleRef + bool DoubleRefToPosSingleRef( const ScRange& rRange, ScAddress& rAdr ); + double GetDoubleFromMatrix(const ScMatrixRef& pMat); + double GetDouble(); + double GetDoubleWithDefault(double nDefault); + bool IsMissing() const; + sal_Int32 double_to_int32(double fVal); + /** if GetDouble() not within int32 limits sets nGlobalError and returns SAL_MAX_INT32 */ + sal_Int32 GetInt32(); + /** if GetDoubleWithDefault() not within int32 limits sets nGlobalError and returns SAL_MAX_INT32 */ + sal_Int32 GetInt32WithDefault( sal_Int32 nDefault ); + /** if GetDouble() not within int16 limits sets nGlobalError and returns SAL_MAX_INT16 */ + sal_Int16 GetInt16(); + /** if GetDouble() not within uint32 limits sets nGlobalError and returns SAL_MAX_UINT32 */ + sal_uInt32 GetUInt32(); + bool GetBool() { return GetDouble() != 0.0; } + /// returns TRUE if double (or error, check nGlobalError), else FALSE + bool GetDoubleOrString( double& rValue, svl::SharedString& rString ); + svl::SharedString GetString(); + svl::SharedString GetStringFromMatrix(const ScMatrixRef& pMat); + svl::SharedString GetStringFromDouble( const double fVal); + // pop matrix and obtain one element, upper left or according to jump matrix + ScMatValType GetDoubleOrStringFromMatrix( double& rDouble, svl::SharedString& rString ); + ScMatrixRef CreateMatrixFromDoubleRef( const formula::FormulaToken* pToken, + SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2 ); + inline ScTokenMatrixMap& GetTokenMatrixMap(); + ScMatrixRef GetMatrix(); + ScMatrixRef GetMatrix( short & rParam, size_t & rInRefList ); + sc::RangeMatrix GetRangeMatrix(); + + void ScTableOp(); // repeated operations + + // common helper functions + + void CurFmtToFuncFmt() + { nFuncFmtType = nCurFmtType; nFuncFmtIndex = nCurFmtIndex; } + + /** Check if a double is suitable as string position or length argument. + + If fVal is Inf or NaN it is changed to -1, if it is less than 0 it is + sanitized to 0, if it is greater than some implementation defined max + string length it is sanitized to that max. + + @return TRUE if double value fVal is suitable as string argument and was + not sanitized. + FALSE if not and fVal was adapted. + */ + static inline bool CheckStringPositionArgument( double & fVal ); + + /** Obtain a sal_Int32 suitable as string position or length argument. + Returns -1 if the number is Inf or NaN or less than 0 or greater than some + implementation defined max string length. In these cases also sets + nGlobalError to FormulaError::IllegalArgument, if not already set. */ + inline sal_Int32 GetStringPositionArgument(); + + // Check for String overflow of rResult+rAdd and set error and erase rResult + // if so. Return true if ok, false if overflow + inline bool CheckStringResultLen( OUString& rResult, sal_Int32 nIncrease ); + + // Check for String overflow of rResult+rAdd and set error and erase rResult + // if so. Return true if ok, false if overflow + inline bool CheckStringResultLen( OUStringBuffer& rResult, sal_Int32 nIncrease ); + + // Set error according to rVal, and set rVal to 0.0 if there was an error. + inline void TreatDoubleError( double& rVal ); + // Lookup using ScLookupCache, @returns true if found and result address + bool LookupQueryWithCache( ScAddress & o_rResultPos, + const ScQueryParam & rParam, const ScComplexRefData* refData ) const; + + void ScIfJump(); + void ScIfError( bool bNAonly ); + void ScChooseJump(); + + // Be sure to only call this if pStack[sp-nStackLevel] really contains a + // ScJumpMatrixToken, no further checks are applied! + // Returns true if last jump was executed and result matrix pushed. + bool JumpMatrix( short nStackLevel ); + + double Compare( ScQueryOp eOp ); + /** @param pOptions + NULL means case sensitivity document option is to be used! + */ + sc::RangeMatrix CompareMat( ScQueryOp eOp, sc::CompareOptions* pOptions = nullptr ); + ScMatrixRef QueryMat( const ScMatrixRef& pMat, sc::CompareOptions& rOptions ); + void ScEqual(); + void ScNotEqual(); + void ScLess(); + void ScGreater(); + void ScLessEqual(); + void ScGreaterEqual(); + void ScAnd(); + void ScOr(); + void ScXor(); + void ScNot(); + void ScNeg(); + void ScPercentSign(); + void ScIntersect(); + void ScRangeFunc(); + void ScUnionFunc(); + void ScPi(); + void ScRandom(); + void ScRandbetween(); + void ScRandomImpl( const std::function& RandomFunc, + double fFirst, double fLast ); + void ScTrue(); + void ScFalse(); + void ScDeg(); + void ScRad(); + void ScSin(); + void ScCos(); + void ScTan(); + void ScCot(); + void ScArcSin(); + void ScArcCos(); + void ScArcTan(); + void ScArcCot(); + void ScSinHyp(); + void ScCosHyp(); + void ScTanHyp(); + void ScCotHyp(); + void ScArcSinHyp(); + void ScArcCosHyp(); + void ScArcTanHyp(); + void ScArcCotHyp(); + void ScCosecant(); + void ScSecant(); + void ScCosecantHyp(); + void ScSecantHyp(); + void ScExp(); + void ScLn(); + void ScLog10(); + void ScSqrt(); + void ScIsEmpty(); + bool IsString(); + void ScIsString(); + void ScIsNonString(); + void ScIsLogical(); + void ScType(); + void ScCell(); + void ScCellExternal(); + void ScIsRef(); + void ScIsValue(); + void ScIsFormula(); + void ScFormula(); + void ScRoman(); + void ScArabic(); + void ScIsNV(); + void ScIsErr(); + void ScIsError(); + bool IsEven(); + void ScIsEven(); + void ScIsOdd(); + void ScN(); + void ScCode(); + void ScTrim(); + void ScUpper(); + void ScProper(); + void ScLower(); + void ScLen(); + void ScT(); + void ScValue(); + void ScNumberValue(); + void ScClean(); + void ScChar(); + void ScJis(); + void ScAsc(); + void ScUnicode(); + void ScUnichar(); + void ScMin( bool bTextAsZero = false ); + void ScMax( bool bTextAsZero = false ); + /** Check for array of references to determine the maximum size of a return + column vector if in array context. */ + size_t GetRefListArrayMaxSize( short nParamCount ); + /** Switch to array reference list if current TOS is one and create/init or + update matrix and return true. Else return false. */ + bool SwitchToArrayRefList( ScMatrixRef& xResMat, SCSIZE nMatRows, double fCurrent, + const std::function& MatOpFunc, bool bDoMatOp ); + void IterateParameters( ScIterFunc, bool bTextAsZero = false ); + void ScSumSQ(); + void ScSum(); + void ScProduct(); + void ScAverage( bool bTextAsZero = false ); + void ScCount(); + void ScCount2(); + void GetStVarParams( bool bTextAsZero, double(*VarResult)( double fVal, size_t nValCount ) ); + void ScVar( bool bTextAsZero = false ); + void ScVarP( bool bTextAsZero = false ); + void ScStDev( bool bTextAsZero = false ); + void ScStDevP( bool bTextAsZero = false ); + void ScRawSubtract(); + void ScColumns(); + void ScRows(); + void ScSheets(); + void ScColumn(); + void ScRow(); + void ScSheet(); + void ScMatch(); + void IterateParametersIf( ScIterFuncIf ); + void ScCountIf(); + void ScSumIf(); + void ScAverageIf(); + void IterateParametersIfs( double(*ResultFunc)( const sc::ParamIfsResult& rRes ) ); + void ScSumIfs(); + void ScAverageIfs(); + void ScCountIfs(); + void ScCountEmptyCells(); + void ScLookup(); + void ScHLookup(); + void ScVLookup(); + void ScSubTotal(); + + // If upon call rMissingField==true then the database field parameter may be + // missing (Xcl DCOUNT() syntax), or may be faked as missing by having the + // value 0.0 or being exactly the entire database range reference (old SO + // compatibility). If this was the case then rMissingField is set to true upon + // return. If rMissingField==false upon call all "missing cases" are considered + // to be an error. + std::unique_ptr GetDBParams( bool& rMissingField ); + + void DBIterator( ScIterFunc ); + void ScDBSum(); + void ScDBCount(); + void ScDBCount2(); + void ScDBAverage(); + void ScDBGet(); + void ScDBMax(); + void ScDBMin(); + void ScDBProduct(); + void GetDBStVarParams( double& rVal, double& rValCount ); + void ScDBStdDev(); + void ScDBStdDevP(); + void ScDBVar(); + void ScDBVarP(); + void ScIndirect(); + void ScAddressFunc(); + void ScOffset(); + void ScIndex(); + void ScMultiArea(); + void ScAreas(); + void ScCurrency(); + void ScReplace(); + void ScFixed(); + void ScFind(); + void ScExact(); + void ScLeft(); + void ScRight(); + void ScSearch(); + void ScMid(); + void ScText(); + void ScSubstitute(); + void ScRept(); + void ScRegex(); + void ScConcat(); + void ScConcat_MS(); + void ScTextJoin_MS(); + void ScIfs_MS(); + void ScSwitch_MS(); + void ScMinIfs_MS(); + void ScMaxIfs_MS(); + void ScExternal(); + void ScMissing(); + void ScMacro(); + bool SetSbxVariable( SbxVariable* pVar, const ScAddress& ); + FormulaError GetErrorType(); + void ScErrorType(); + void ScErrorType_ODF(); + void ScDBArea(); + void ScColRowNameAuto(); + void ScGetPivotData(); + void ScHyperLink(); + void ScBahtText(); + void ScBitAnd(); + void ScBitOr(); + void ScBitXor(); + void ScBitRshift(); + void ScBitLshift(); + void ScTTT(); + void ScDebugVar(); + + /** Obtain the date serial number for a given date. + @param bStrict + If false, nYear < 100 takes the two-digit year setting into account, + and rollover of invalid calendar dates takes place, e.g. 1999-02-31 => + 1999-03-03. + If true, the date passed must be a valid Gregorian calendar date. No + two-digit expanding or rollover is done. + + Date must be Gregorian, i.e. >= 1582-10-15. + */ + double GetDateSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, bool bStrict ); + + void ScGetActDate(); + void ScGetActTime(); + void ScGetYear(); + void ScGetMonth(); + void ScGetDay(); + void ScGetDayOfWeek(); + void ScGetWeekOfYear(); + void ScGetIsoWeekOfYear(); + void ScWeeknumOOo(); + void ScEasterSunday(); + FormulaError GetWeekendAndHolidayMasks( const sal_uInt8 nParamCount, const sal_uInt32 nNullDate, + ::std::vector& rSortArray, bool bWeekendMask[ 7 ] ); + FormulaError GetWeekendAndHolidayMasks_MS( const sal_uInt8 nParamCount, const sal_uInt32 nNullDate, + ::std::vector& rSortArray, bool bWeekendMask[ 7 ], bool bWorkdayFunction ); + static inline sal_Int16 GetDayOfWeek( sal_Int32 n ); + void ScNetWorkdays( bool bOOXML_Version ); + void ScWorkday_MS(); + void ScGetHour(); + void ScGetMin(); + void ScGetSec(); + void ScPlusMinus(); + void ScAbs(); + void ScInt(); + void ScEven(); + void ScOdd(); + void ScCeil( bool bODFF ); + void ScCeil_MS(); + void ScCeil_Precise(); + void ScFloor( bool bODFF ); + void ScFloor_MS(); + void ScFloor_Precise(); + void RoundNumber( rtl_math_RoundingMode eMode ); + void ScRound(); + void ScRoundUp(); + void ScRoundDown(); + void ScGetDateValue(); + void ScGetTimeValue(); + void ScArcTan2(); + void ScLog(); + void ScGetDate(); + void ScGetTime(); + void ScGetDiffDate(); + void ScGetDiffDate360(); + void ScGetDateDif(); + void ScPower(); + void ScAmpersand(); + void ScAdd(); + void ScSub(); + void ScMul(); + void ScDiv(); + void ScPow(); + void ScCurrent(); + void ScStyle(); + void ScDde(); + void ScBase(); + void ScDecimal(); + void ScConvertOOo(); + void ScEuroConvert(); + void ScRoundSignificant(); + static void RoundSignificant( double fX, double fDigits, double &fRes ); + + // financial functions + void ScNPV(); + void ScIRR(); + void ScMIRR(); + void ScISPMT(); + + static double ScGetPV(double fRate, double fNper, double fPmt, + double fFv, bool bPayInAdvance); + void ScPV(); + void ScSYD(); + static double ScGetDDB(double fCost, double fSalvage, double fLife, + double fPeriod, double fFactor); + void ScDDB(); + void ScDB(); + static double ScInterVDB(double fCost, double fSalvage, double fLife, double fLife1, + double fPeriod, double fFactor); + void ScVDB(); + void ScPDuration(); + void ScSLN(); + static double ScGetPMT(double fRate, double fNper, double fPv, + double fFv, bool bPayInAdvance); + void ScPMT(); + void ScRRI(); + static double ScGetFV(double fRate, double fNper, double fPmt, + double fPv, bool bPayInAdvance); + void ScFV(); + void ScNper(); + static bool RateIteration(double fNper, double fPayment, double fPv, + double fFv, bool bPayType, double& fGuess); + void ScRate(); + double ScGetIpmt(double fRate, double fPer, double fNper, double fPv, + double fFv, bool bPayInAdvance, double& fPmt); + void ScIpmt(); + void ScPpmt(); + void ScCumIpmt(); + void ScCumPrinc(); + void ScEffect(); + void ScNominal(); + void ScMod(); + void ScIntercept(); + void ScGCD(); + void ScLCM(); + + // matrix functions + void ScMatValue(); + static void MEMat(const ScMatrixRef& mM, SCSIZE n); + void ScMatDet(); + void ScMatInv(); + void ScMatMult(); + void ScMatTrans(); + void ScEMat(); + void ScMatRef(); + ScMatrixRef MatConcat(const ScMatrixRef& pMat1, const ScMatrixRef& pMat2); + void ScSumProduct(); + void ScSumX2MY2(); + void ScSumX2DY2(); + void ScSumXMY2(); + void ScGrowth(); + bool CalculateSkew(KahanSum& fSum, double& fCount, std::vector& values); + void CalculateSkewOrSkewp( bool bSkewp ); + void CalculateSlopeIntercept(bool bSlope); + void CalculateSmallLarge(bool bSmall); + void CalculatePearsonCovar( bool _bPearson, bool _bStexy, bool _bSample ); //fdo#70000 argument _bSample is ignored if _bPearson == true + bool CalculateTest( bool _bTemplin + ,const SCSIZE nC1, const SCSIZE nC2,const SCSIZE nR1,const SCSIZE nR2 + ,const ScMatrixRef& pMat1,const ScMatrixRef& pMat2 + ,double& fT,double& fF); + void CalculateLookup(bool bHLookup); + bool FillEntry(ScQueryEntry& rEntry); + void CalculateAddSub(bool _bSub); + void CalculateTrendGrowth(bool _bGrowth); + void CalculateRGPRKP(bool _bRKP); + void CalculateSumX2MY2SumX2DY2(bool _bSumX2DY2); + void CalculateMatrixValue(const ScMatrix* pMat,SCSIZE nC,SCSIZE nR); + bool CheckMatrix(bool _bLOG,sal_uInt8& nCase,SCSIZE& nCX,SCSIZE& nCY,SCSIZE& nRX,SCSIZE& nRY,SCSIZE& M,SCSIZE& N,ScMatrixRef& pMatX,ScMatrixRef& pMatY); + void ScLinest(); + void ScLogest(); + void ScForecast(); + void ScForecast_Ets( ScETSType eETSType ); + void ScFourier(); + void ScNoName(); + void ScBadName(); + // Statistics: + static double taylor(const double* pPolynom, sal_uInt16 nMax, double x); + static double gauss(double x); + +public: + static double phi(double x); + static double integralPhi(double x); + static double gaussinv(double x); + static double GetPercentile( ::std::vector & rArray, double fPercentile ); + + +private: + double GetBetaDist(double x, double alpha, double beta); //cumulative distribution function + double GetBetaDistPDF(double fX, double fA, double fB); //probability density function) + double GetChiDist(double fChi, double fDF); // for LEGACY.CHIDIST, returns right tail + double GetChiSqDistCDF(double fX, double fDF); // for CHISQDIST, returns left tail + static double GetChiSqDistPDF(double fX, double fDF); // probability density function + double GetFDist(double x, double fF1, double fF2); + double GetTDist( double T, double fDF, int nType ); + double Fakultaet(double x); + static double BinomKoeff(double n, double k); + double GetGamma(double x); + static double GetLogGamma(double x); + double GetBeta(double fAlpha, double fBeta); + static double GetLogBeta(double fAlpha, double fBeta); + double GetBinomDistPMF(double x, double n, double p); //probability mass function + double GetHypGeomDist( double x, double n, double M, double N ); + void ScLogGamma(); + void ScGamma(); + void ScPhi(); + void ScGauss(); + void ScStdNormDist(); + void ScStdNormDist_MS(); + void ScFisher(); + void ScFisherInv(); + void ScFact(); + void ScNormDist( int nMinParamCount ); + void ScGammaDist( bool bODFF ); + void ScGammaInv(); + void ScExpDist(); + void ScBinomDist(); + void ScPoissonDist( bool bODFF ); + void ScCombin(); + void ScCombinA(); + void ScPermut(); + void ScPermutationA(); + void ScB(); + void ScHypGeomDist( int nMinParamCount ); + void ScLogNormDist( int nMinParamCount ); + void ScLogNormInv(); + void ScTDist(); + void ScTDist_MS(); + void ScTDist_T( int nTails ); + void ScFDist(); + void ScFDist_LT(); + void ScChiDist( bool bODFF); // for LEGACY.CHIDIST, returns right tail + void ScChiSqDist(); // returns left tail or density + void ScChiSqDist_MS(); + void ScChiSqInv(); // inverse to CHISQDIST + void ScWeibull(); + void ScBetaDist(); + void ScBetaDist_MS(); + void ScFInv(); + void ScFInv_LT(); + void ScTInv( int nType ); + void ScChiInv(); + void ScBetaInv(); + void ScCritBinom(); + void ScNegBinomDist(); + void ScNegBinomDist_MS(); + void ScKurt(); + void ScHarMean(); + void ScGeoMean(); + void ScStandard(); + void ScSkew(); + void ScSkewp(); + void ScMedian(); + double GetMedian( ::std::vector & rArray ); + double GetPercentileExclusive( ::std::vector & rArray, double fPercentile ); + std::vector GetTopNumberArray( SCSIZE& rCol, SCSIZE& rRow ); + void GetNumberSequenceArray( sal_uInt8 nParamCount, ::std::vector& rArray, bool bConvertTextInArray ); + void GetSortArray( sal_uInt8 nParamCount, ::std::vector& rSortArray, ::std::vector* pIndexOrder, bool bConvertTextInArray, bool bAllowEmptyArray ); + static void QuickSort(::std::vector& rSortArray, ::std::vector* pIndexOrder); + void ScModalValue(); + void ScModalValue_MS( bool bSingle ); + void ScAveDev(); + void ScAggregate(); + void ScDevSq(); + void ScZTest(); + void ScTTest(); + void ScFTest(); + void ScChiTest(); + void ScRank( bool bAverage ); + void ScPercentile( bool bInclusive ); + void ScPercentrank( bool bInclusive ); + static double GetPercentrank( ::std::vector & rArray, double fVal, bool bInclusive ); + void ScLarge(); + void ScSmall(); + void ScFrequency(); + void ScQuartile( bool bInclusive ); + void ScNormInv(); + void ScSNormInv(); + void ScConfidence(); + void ScConfidenceT(); + void ScTrimMean(); + void ScProbability(); + void ScCorrel(); + void ScCovarianceP(); + void ScCovarianceS(); + void ScPearson(); + void ScRSQ(); + void ScSTEYX(); + void ScSlope(); + void ScTrend(); + void ScInfo(); + void ScLenB(); + void ScRightB(); + void ScLeftB(); + void ScMidB(); + void ScReplaceB(); + void ScFindB(); + void ScSearchB(); + + void ScFilterXML(); + void ScWebservice(); + void ScEncodeURL(); + void ScColor(); + void ScErf(); + void ScErfc(); + + static const double fMaxGammaArgument; + + double GetGammaContFraction(double fA,double fX); + double GetGammaSeries(double fA,double fX); + double GetLowRegIGamma(double fA,double fX); // lower regularized incomplete gamma function, GAMMAQ + double GetUpRegIGamma(double fA,double fX); // upper regularized incomplete gamma function, GAMMAP + // probability density function; fLambda is "scale" parameter + double GetGammaDistPDF(double fX, double fAlpha, double fLambda); + // cumulative distribution function; fLambda is "scale" parameter + double GetGammaDist(double fX, double fAlpha, double fLambda); + double GetTInv( double fAlpha, double fSize, int nType ); + +public: + ScInterpreter( ScFormulaCell* pCell, ScDocument& rDoc, ScInterpreterContext& rContext, + const ScAddress&, ScTokenArray&, bool bForGroupThreading = false ); + ~ScInterpreter(); + + // Used only for threaded formula-groups. + // Resets the interpreter object, allowing reuse of interpreter object for each cell + // in the group. + void Init( ScFormulaCell* pCell, const ScAddress& rPos, ScTokenArray& rTokArray ); + + formula::StackVar Interpret(); + + void SetError(FormulaError nError) + { if (nError != FormulaError::NONE && nGlobalError == FormulaError::NONE) nGlobalError = nError; } + void AssertFormulaMatrix(); + + void SetLinkManager(sfx2::LinkManager* pLinkMgr) + { mpLinkManager = pLinkMgr; } + + FormulaError GetError() const { return nGlobalError; } + formula::StackVar GetResultType() const { return xResult->GetType(); } + const svl::SharedString & GetStringResult() const; + double GetNumResult() const { return xResult->GetDouble(); } + const formula::FormulaConstTokenRef& GetResultToken() const { return xResult; } + SvNumFormatType GetRetFormatType() const { return nRetFmtType; } + sal_uLong GetRetFormatIndex() const { return nRetFmtIndex; } +}; + +inline bool ScInterpreter::IsInArrayContext() const +{ + return bMatrixFormula || pCur->IsInForceArray(); +} + +inline void ScInterpreter::MatrixJumpConditionToMatrix() +{ + if (IsInArrayContext()) + ConvertMatrixJumpConditionToMatrix(); +} + +inline bool ScInterpreter::MatrixParameterConversion() +{ + if ( (IsInArrayContext() || ScParameterClassification::HasForceArray( pCur->GetOpCode())) && + !pJumpMatrix && sp > 0 ) + return ConvertMatrixParameters(); + return false; +} + +inline ScTokenMatrixMap& ScInterpreter::GetTokenMatrixMap() +{ + return maTokenMatrixMap; +} + +inline bool ScInterpreter::MustHaveParamCount( short nAct, short nMust ) +{ + if ( nAct == nMust ) + return true; + if ( nAct < nMust ) + PushParameterExpected(); + else + PushIllegalParameter(); + return false; +} + +inline bool ScInterpreter::MustHaveParamCount( short nAct, short nMust, short nMax ) +{ + if ( nMust <= nAct && nAct <= nMax ) + return true; + if ( nAct < nMust ) + PushParameterExpected(); + else + PushIllegalParameter(); + return false; +} + +inline bool ScInterpreter::MustHaveParamCountMin( short nAct, short nMin ) +{ + if ( nAct >= nMin ) + return true; + PushParameterExpected(); + return false; +} + +inline bool ScInterpreter::MustHaveParamCountMinWithStackCheck( short nAct, short nMin ) +{ + assert(sp >= nAct); + if (sp < nAct) + { + PushParameterExpected(); + return false; + } + return MustHaveParamCountMin( nAct, nMin); +} + +inline bool ScInterpreter::CheckStringPositionArgument( double & fVal ) +{ + if (!std::isfinite( fVal)) + { + fVal = -1.0; + return false; + } + else if (fVal < 0.0) + { + fVal = 0.0; + return false; + } + else if (fVal > SAL_MAX_INT32) + { + fVal = static_cast(SAL_MAX_INT32); + return false; + } + return true; +} + +inline sal_Int32 ScInterpreter::GetStringPositionArgument() +{ + double fVal = rtl::math::approxFloor( GetDouble()); + if (!CheckStringPositionArgument( fVal)) + { + fVal = -1.0; + SetError( FormulaError::IllegalArgument); + } + return static_cast(fVal); +} + +inline bool ScInterpreter::CheckStringResultLen( OUString& rResult, sal_Int32 nIncrease ) +{ + if (nIncrease > kScInterpreterMaxStrLen - rResult.getLength()) + { + SetError( FormulaError::StringOverflow ); + rResult.clear(); + return false; + } + return true; +} + +inline bool ScInterpreter::CheckStringResultLen( OUStringBuffer& rResult, sal_Int32 nIncrease ) +{ + if (nIncrease > kScInterpreterMaxStrLen - rResult.getLength()) + { + SetError( FormulaError::StringOverflow ); + rResult.setLength(0); + return false; + } + return true; +} + +inline void ScInterpreter::TreatDoubleError( double& rVal ) +{ + if ( !std::isfinite( rVal ) ) + { + FormulaError nErr = GetDoubleErrorValue( rVal ); + if ( nErr != FormulaError::NONE ) + SetError( nErr ); + else + SetError( FormulaError::NoValue ); + rVal = 0.0; + } +} + +inline double ScInterpreter::div( const double& fNumerator, const double& fDenominator ) +{ + return sc::div(fNumerator, fDenominator); +} + +inline sal_Int16 ScInterpreter::GetDayOfWeek( sal_Int32 n ) +{ // monday = 0, ..., sunday = 6 + return static_cast< sal_Int16 >( ( n - 1 ) % 7 ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/jumpmatrix.hxx b/sc/source/core/inc/jumpmatrix.hxx new file mode 100644 index 000000000..f0fb9c1ab --- /dev/null +++ b/sc/source/core/inc/jumpmatrix.hxx @@ -0,0 +1,122 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include +#include +#include +#include + +namespace formula { class FormulaToken; } + +typedef ::std::vector< const formula::FormulaToken*> ScTokenVec; + +struct ScJumpMatrixEntry +{ + double fBool; // 0:= false 1:= true also if no-path + // other values may contain error conditions like NAN and INF + short nStart; // start of path (actually start-1, see formula::FormulaTokenIterator) + short nNext; // next after path + // jump path exists if nStart != nNext, else no path + short nStop; // optional stop of path (nPC < nStop) + + void SetJump( double fBoolP, short nStartP, short nNextP, short nStopP ) + { + fBool = fBoolP; + nStart = nStartP; + nNext = nNextP; + nStop = nStopP; + } + void GetJump( double& rBool, short& rStart, short& rNext, short& rStop ) const + { + rBool = fBool; + rStart = nStart; + rNext = nNext; + rStop = nStop; + } +}; + +class ScJumpMatrix +{ + std::vector mvJump; // the jumps + ScMatrixRef pMat; // the results + ScRefList mvRefList; // array of references result, if any + ScTokenVec mvParams; // parameter stack + SCSIZE nCols; + SCSIZE nRows; + SCSIZE nCurCol; + SCSIZE nCurRow; + SCSIZE nResMatCols; + SCSIZE nResMatRows; + OpCode meOp; + bool bStarted; + + // Buffer result ranges to be able to set a range of identically typed + // values at the result matrix in order to avoid multiple shrinks and + // growths of multi_type_vector segments, which is a major performance + // bottleneck, see fdo#72929 + ::std::vector< svl::SharedString > mvBufferStrings; + ::std::vector< double > mvBufferDoubles; + SCSIZE mnBufferCol; + SCSIZE mnBufferRowStart; + SCSIZE mnBufferEmptyCount; + SCSIZE mnBufferEmptyPathCount; + + enum BufferType + { + BUFFER_NONE, + BUFFER_DOUBLE, + BUFFER_STRING, + BUFFER_EMPTY, + BUFFER_EMPTYPATH + }; + + /** Flush different types or non-consecutive buffers. */ + void FlushBufferOtherThan( BufferType eType, SCSIZE nC, SCSIZE nR ); + + ScJumpMatrix( const ScJumpMatrix& ) = delete; + ScJumpMatrix& operator=( const ScJumpMatrix& ) = delete; + +public: + ScJumpMatrix( OpCode eOp, SCSIZE nColsP, SCSIZE nRowsP ); + ~ScJumpMatrix(); + void GetDimensions( SCSIZE& rCols, SCSIZE& rRows ) const; + void SetJump( SCSIZE nCol, SCSIZE nRow, double fBool, short nStart, short nNext ); + void GetJump( SCSIZE nCol, SCSIZE nRow, double& rBool, short& rStart, short& rNext, short& rStop ) const; + void SetAllJumps( double fBool, short nStart, short nNext, short nStop = SHRT_MAX ); + void SetJumpParameters( ScTokenVec&& p ); + const ScTokenVec & GetJumpParameters() const { return mvParams;} + bool HasResultMatrix() const; + ScMatrix* GetResultMatrix(); ///< also applies pending buffered values + void GetPos( SCSIZE& rCol, SCSIZE& rRow ) const; + bool Next( SCSIZE& rCol, SCSIZE& rRow ); + void GetResMatDimensions( SCSIZE& rCols, SCSIZE& rRows ); + void SetNewResMat( SCSIZE nNewCols, SCSIZE nNewRows ); + ScRefList& GetRefList(); + OpCode GetOpCode() const { return meOp; } + + void PutResultDouble( double fVal, SCSIZE nC, SCSIZE nR ); + void PutResultString( const svl::SharedString& rStr, SCSIZE nC, SCSIZE nR ); + void PutResultEmpty( SCSIZE nC, SCSIZE nR ); + void PutResultEmptyPath( SCSIZE nC, SCSIZE nR ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/parclass.hxx b/sc/source/core/inc/parclass.hxx new file mode 100644 index 000000000..4b043fd7f --- /dev/null +++ b/sc/source/core/inc/parclass.hxx @@ -0,0 +1,144 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include + +/** Activate parameter classification documentation. + + Building with DEBUG_SC_PARCLASSDOC 1 enables generation of parameter + classification documentation when instantiating the first Calc document if + the environment variable OOO_CALC_GENPARCLASSDOC is set and SAL_LOG + contains +INFO.sc.core + + Generated output contains CALC_GENPARCLASSDOC that can be easily grep'ed for. + + Activation adds overhead to Calc initialization time to gather information + that otherwise is not needed for anything else. + */ +#define DEBUG_SC_PARCLASSDOC 0 + +namespace formula +{ + class FormulaToken; +} + +class ScParameterClassification +{ +public: + + /// MUST be called once before any other method. + static void Init(); + + static void Exit(); + + /** Get one parameter type for function eOp. + @param nParameter + Which parameter, 0-based. + SAL_MAX_UINT16 for return type of eOp. + */ + static formula::ParamClass GetParameterType( const formula::FormulaToken* pToken, + sal_uInt16 nParameter); + + /** Whether OpCode has a parameter of type + ForceArray or ReferenceOrForceArray. */ + static bool HasForceArray( OpCode eOp) + { + return 0 <= static_cast(eOp) && + eOp <= SC_OPCODE_LAST_OPCODE_ID && + pData[eOp].bHasForceArray; + } + +private: + + struct CommonData + { + const static sal_Int32 nMaxParams = 7; + + formula::ParamClass nParam[nMaxParams]; + sal_uInt8 nRepeatLast; + formula::ParamClass eReturn; + }; + + struct RawData + { + OpCode eOp; + CommonData aData; + }; + + struct RunData; + friend struct ScParameterClassification::RunData; + struct RunData + { + CommonData aData; + sal_uInt8 nMinParams; // fix or minimum, or repeat start + bool bHasForceArray; + }; + + static const RawData pRawData[]; + static RunData* pData; + + // ocExternal AddIns + static formula::ParamClass GetExternalParameterType( + const formula::FormulaToken* pToken, sal_uInt16 nParameter); + +#if DEBUG_SC_PARCLASSDOC + // Generate documentation to stdout if environment variable + // OOO_CALC_GENPARCLASSDOC is set. + static void GenerateDocumentation(); + + /* OpCodes not specified in the implementation are taken from the global + * function list and all parameters, if any, are assumed to be of type + * Value. This could also be done in the product version if needed, but we + * don't want to spoil startup time. However, doing so could propagate the + * minimum parameter count to the formula compiler, which, together with + * additional information about optional parameters, could react on missing + * parameters then. */ + static void MergeArgumentsFromFunctionResource(); + + /** Minimum number of parameters, or fix number + of parameters if HasRepeatParameters() + returns sal_False. For opcodes not specified in + the implementation a parameter count of 1 + is assumed, for opcodes out of range 0 is + assumed. If HasRepeatParameters() returns + sal_True, information is NOT related to whether + any parameters are optional, only the type + of parameters is significant. */ + static inline sal_uInt8 GetMinimumParameters( OpCode eOp) + { + if ( eOp <= SC_OPCODE_LAST_OPCODE_ID ) + return pData[eOp].aData.nParam[0] + == formula::ParamClass::Unknown ? 1 : + pData[eOp].nMinParams; + return 0; + } + + /** Whether last parameter types are repeated. */ + static inline bool HasRepeatParameters( OpCode eOp) + { + return eOp <= SC_OPCODE_LAST_OPCODE_ID + && pData[eOp].aData.nRepeatLast > 0; + } +#endif // DEBUG_SC_PARCLASSDOC +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/poolhelp.hxx b/sc/source/core/inc/poolhelp.hxx new file mode 100644 index 000000000..ed1275da5 --- /dev/null +++ b/sc/source/core/inc/poolhelp.hxx @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include +#include +#include +#include +#include + +class ScDocument; +class ScDocumentPool; +class ScStyleSheetPool; +class SvNumberFormatter; +class SfxItemPool; + +class ScPoolHelper final : public salhelper::SimpleReferenceObject +{ +private: + mutable std::mutex maMtxCreateNumFormatter; + ScDocOptions aOpt; + rtl::Reference pDocPool; + rtl::Reference< ScStyleSheetPool > mxStylePool; + mutable std::unique_ptr pFormTable; + mutable rtl::Reference pEditPool; // EditTextObjectPool + mutable rtl::Reference pEnginePool; // EditEnginePool + ScDocument& m_rSourceDoc; + +public: + ScPoolHelper( ScDocument& rSourceDoc ); + virtual ~ScPoolHelper() override; + + // called in dtor of main document + void SourceDocumentGone(); + + // access to pointers (are never 0): + ScDocumentPool* GetDocPool() const { return pDocPool.get(); } + ScStyleSheetPool* GetStylePool() const { return mxStylePool.get(); } + SvNumberFormatter* GetFormTable() const; + SfxItemPool* GetEditPool() const; + SfxItemPool* GetEnginePool() const; + + void SetFormTableOpt(const ScDocOptions& rOpt); + + std::unique_ptr CreateNumberFormatter() const; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/refupdat.hxx b/sc/source/core/inc/refupdat.hxx new file mode 100644 index 000000000..cd3ab69df --- /dev/null +++ b/sc/source/core/inc/refupdat.hxx @@ -0,0 +1,71 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +class ScDocument; +class ScBigRange; +struct ScComplexRefData; +class ScAddress; +class ScRange; + +enum ScRefUpdateRes { + UR_NOTHING = 0, ///< Reference not affected, no change at all. + UR_UPDATED = 1, ///< Reference was adjusted/updated. + UR_INVALID = 2, ///< Some part of the reference became invalid. + UR_STICKY = 3 /**< Not updated because the reference is sticky, + but would had been updated if it wasn't. For + entire columns/rows. Essentially the same as + not UR_NOTHING for the caller but allows + differentiation. */ +}; + +class ScRefUpdate +{ +public: + + static ScRefUpdateRes Update + ( const ScDocument* pDoc, UpdateRefMode eUpdateRefMode, + SCCOL nCol1, SCROW nRow1, SCTAB nTab1, + SCCOL nCol2, SCROW nRow2, SCTAB nTab2, + SCCOL nDx, SCROW nDy, SCTAB nDz, + SCCOL& theCol1, SCROW& theRow1, SCTAB& theTab1, + SCCOL& theCol2, SCROW& theRow2, SCTAB& theTab2 ); + + static ScRefUpdateRes Update( UpdateRefMode eUpdateRefMode, + const ScBigRange& rWhere, + sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz, + ScBigRange& rWhat ); + + static void MoveRelWrap( const ScDocument& rDoc, const ScAddress& rPos, + SCCOL nMaxCol, SCROW nMaxRow, ScComplexRefData& rRef ); + + static ScRefUpdateRes UpdateTranspose( + const ScDocument& rDoc, const ScRange& rSource, const ScAddress& rDest, ScRange& rRef ); + + static void DoTranspose( SCCOL& rCol, SCROW& rRow, SCTAB& rTab, const ScDocument& rDoc, + const ScRange& rSource, const ScAddress& rDest ); + + static ScRefUpdateRes UpdateGrow( + const ScRange& rArea, SCCOL nGrowX, SCROW nGrowY, ScRange& rRef ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/scrdata.hxx b/sc/source/core/inc/scrdata.hxx new file mode 100644 index 000000000..0698e1257 --- /dev/null +++ b/sc/source/core/inc/scrdata.hxx @@ -0,0 +1,37 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +namespace com::sun::star::i18n +{ +class XBreakIterator; +} + +class ScScriptTypeData +{ +public: + css::uno::Reference xBreakIter; + + ScScriptTypeData() {} +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/sharedstringpoolpurge.hxx b/sc/source/core/inc/sharedstringpoolpurge.hxx new file mode 100644 index 000000000..76ed42b7e --- /dev/null +++ b/sc/source/core/inc/sharedstringpoolpurge.hxx @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + */ + +#pragma once + +#include +#include + +#include +#include + +namespace svl +{ +class SharedStringPool; +} + +namespace sc +{ +/* +Calls svl::SharedStringPool::purge() after a delay when idle. Can be +used to compress repeated calls, as purge() may be somewhat expensive +with large documents. And since vcl links to svl, it's not possible +to use VCL timers in svl, so a separate class is needed. +*/ +class SharedStringPoolPurge +{ +public: + SharedStringPoolPurge(); + ~SharedStringPoolPurge(); + void delayedPurge(const std::shared_ptr& pool); + +private: + void cleanup(); + std::vector> mPoolsToPurge; + Timer mTimer; + static SharedStringPoolPurge* self; + DECL_LINK(timerHandler, Timer*, void); +}; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/inc/webservicelink.hxx b/sc/source/core/inc/webservicelink.hxx new file mode 100644 index 000000000..7f1d1e913 --- /dev/null +++ b/sc/source/core/inc/webservicelink.hxx @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#pragma once + +#include +#include + +namespace com::sun::star::uno +{ +class Any; +} + +class ScDocument; + +class ScWebServiceLink final : public ::sfx2::SvBaseLink, public SvtBroadcaster +{ +private: + ScDocument* pDoc; + OUString aURL; // connection/ link data + bool bHasResult; // is set aResult is useful + OUString aResult; + +public: + ScWebServiceLink(ScDocument* pD, const OUString& rURL); + virtual ~ScWebServiceLink() override; + + // SvBaseLink override: + virtual ::sfx2::SvBaseLink::UpdateResult DataChanged(const OUString& rMimeType, + const css::uno::Any& rValue) override; + + // SvtBroadcaster override: + virtual void ListenersGone() override; + + // for interpreter: + + const OUString& GetResult() const { return aResult; } + bool HasResult() const { return bHasResult; } + + const OUString& GetURL() const { return aURL; } +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ -- cgit v1.2.3