/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

Bug Summary

File:	home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:	line 192, column 9 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name documen2.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SC_DLLIMPLEMENTATION -D SC_INFO_OSVERSION="LINUX" -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/liborcus/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/mdds/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/clew/source/include -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sc/source/core/inc -I /home/maarten/src/libreoffice/core/sc/source/filter/inc -I /home/maarten/src/libreoffice/core/sc/source/ui/inc -I /home/maarten/src/libreoffice/core/sc/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sc/sdi -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx

/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#include <scextopt.hxx>
21#include <autonamecache.hxx>

23#include <o3tl/safeint.hxx>
24#include <osl/thread.h>
25#include <svx/xtable.hxx>
26#include <sfx2/bindings.hxx>
27#include <sfx2/objsh.hxx>
28#include <sfx2/docfile.hxx>
29#include <sfx2/printer.hxx>
30#include <svl/asiancfg.hxx>
31#include <vcl/virdev.hxx>
32#include <svl/sharedstringpool.hxx>
33#include <tools/urlobj.hxx>
34#include <rtl/crc.h>
35#include <basic/basmgr.hxx>
36#include <comphelper/threadpool.hxx>
37#include <sal/log.hxx>

39#include <scmod.hxx>
40#include <document.hxx>
41#include <table.hxx>
42#include <patattr.hxx>
43#include <rangenam.hxx>
44#include <dbdata.hxx>
45#include <chartlock.hxx>
46#include <rechead.hxx>
47#include <global.hxx>
48#include <bcaslot.hxx>
49#include <adiasync.hxx>
50#include <addinlis.hxx>
51#include <chartlis.hxx>
52#include <markdata.hxx>
53#include <validat.hxx>
54#include <detdata.hxx>
55#include <defaultsoptions.hxx>
56#include <sc.hrc>
57#include <ddelink.hxx>
58#include <chgtrack.hxx>
59#include <chgviset.hxx>
60#include <editutil.hxx>
61#include <hints.hxx>
62#include <dpobject.hxx>
63#include <scrdata.hxx>
64#include <poolhelp.hxx>
65#include <unoreflist.hxx>
66#include <listenercalls.hxx>
67#include <recursionhelper.hxx>
68#include <lookupcache.hxx>
69#include <externalrefmgr.hxx>
70#include <viewdata.hxx>
71#include <viewutil.hxx>
72#include <tabprotection.hxx>
73#include <formulaparserpool.hxx>
74#include <clipparam.hxx>
75#include <macromgr.hxx>
76#include <formulacell.hxx>
77#include <clipcontext.hxx>
78#include <refupdatecontext.hxx>
79#include <refreshtimerprotector.hxx>
80#include <scopetools.hxx>
81#include <documentlinkmgr.hxx>
82#include <interpre.hxx>
83#include <tokenstringcontext.hxx>
84#include <docsh.hxx>
85#include <clipoptions.hxx>
86#include <listenercontext.hxx>
87#include <datamapper.hxx>
88#include <drwlayer.hxx>

90using namespace com::sun::star;

92const sal_uInt16 ScDocument::nSrcVer = SC_CURRENT_VERSION0x0205;

94static ScSheetLimits* CreateSheetLimits()
95{
  const ScDefaultsOptions& rOpt = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetDefaultsOptions();
  if (rOpt.GetInitJumboSheets())
      return new ScSheetLimits(MAXCOL_JUMBO, MAXROW_JUMBO);
  else
      return new ScSheetLimits(MAXCOL, MAXROW);
101}

103ScDocument::ScDocument( ScDocumentMode eMode, SfxObjectShell* pDocShell ) :
      mpCellStringPool(std::make_shared<svl::SharedStringPool>(*ScGlobal::getCharClassPtr())),
      mpDocLinkMgr(new sc::DocumentLinkManager(pDocShell)),
      mbFormulaGroupCxtBlockDiscard(false),
      maCalcConfig( ScInterpreter::GetGlobalConfig()),
      mpUndoManager( nullptr ),
      mpShell( pDocShell ),
      mpPrinter( nullptr ),
      mpVirtualDevice_100th_mm( nullptr ),
      pFormatExchangeList( nullptr ),
      mxSheetLimits(CreateSheetLimits()),
      pFormulaTree( nullptr ),
      pEOFormulaTree( nullptr ),
      pFormulaTrack( nullptr ),
      pEOFormulaTrack( nullptr ),
      pPreviewCellStyle( nullptr ),
      maPreviewSelection(*mxSheetLimits),
      nUnoObjectId( 0 ),
      nRangeOverflowType( 0 ),
      aCurTextWidthCalcPos(MaxCol(),0,0),
      nFormulaCodeInTree(0),
      nXMLImportedFormulaCount( 0 ),
      nInterpretLevel(0),
      nMacroInterpretLevel(0),
      nInterpreterTableOpLevel(0),
      maInterpreterContext( *this, nullptr ),
      nFormulaTrackCount(0),
      eHardRecalcState(HardRecalcState::OFF),
      nVisibleTab( 0 ),
      nPosLeft( 0 ),
      nPosTop( 0 ),
      eLinkMode(LM_UNKNOWN),
      bAutoCalc( eMode == SCDOCMODE_DOCUMENT || eMode == SCDOCMODE_FUNCTIONACCESS ),
      bAutoCalcShellDisabled( false ),
      bForcedFormulaPending( false ),
      bCalculatingFormulaTree( false ),
      bIsClip( eMode == SCDOCMODE_CLIP ),
      bIsUndo( eMode == SCDOCMODE_UNDO ),
      bIsFunctionAccess( eMode == SCDOCMODE_FUNCTIONACCESS ),
      bIsVisible( false ),
      bIsEmbedded( false ),
      bInsertingFromOtherDoc( false ),
      bLoadingMedium( false ),
      bImportingXML( false ),
      bCalcingAfterLoad( false ),
      bNoListening( false ),
      mbIdleEnabled(true),
      bInLinkUpdate( false ),
      bChartListenerCollectionNeedsUpdate( false ),
      bHasForcedFormulas( false ),
      bInDtorClear( false ),
      bExpandRefs( false ),
      bDetectiveDirty( false ),
      bLinkFormulaNeedingCheck( false ),
      nAsianCompression(CharCompressType::Invalid),
      nAsianKerning(SC_ASIANKERNING_INVALID0xff),
      bPastingDrawFromOtherDoc( false ),
      nInDdeLinkUpdate( 0 ),
      bInUnoBroadcast( false ),
      bInUnoListenerCall( false ),
      nAdjustHeightLock(0),
      eGrammar( formula::FormulaGrammar::GRAM_NATIVE ),
      bStyleSheetUsageInvalid( true ),
      mbUndoEnabled( true ),
      mbExecuteLinkEnabled( true ),
      mbChangeReadOnlyEnabled( false ),
      mbStreamValidLocked( false ),
      mbUserInteractionEnabled(true),
      mnNamedRangesLockCount(0),
      mbEmbedFonts(false),
      mbEmbedUsedFontsOnly(false),
      mbEmbedFontScriptLatin(true),
      mbEmbedFontScriptAsian(true),
      mbEmbedFontScriptComplex(true),
      mbTrackFormulasPending(false),
      mbFinalTrackFormulas(false),
      mbDocShellRecalc(false),
      mnMutationGuardFlags(0)
181{
  maPreviewSelection = { *mxSheetLimits };
  aCurTextWidthCalcPos = { MaxCol(), 0, 0 };

  SetStorageGrammar( formula::FormulaGrammar::GRAM_STORAGE_DEFAULT);

  eSrcSet = osl_getThreadTextEncoding();

  /* TODO: for SCDOCMODE_FUNCTIONACCESS it might not even be necessary to
   * have all of these available. */
  if ( eMode == SCDOCMODE_DOCUMENT || eMode == SCDOCMODE_FUNCTIONACCESS )
  {
      mxPoolHelper = new ScPoolHelper( *this );

      pBASM.reset( new ScBroadcastAreaSlotMachine( this ) );
      pChartListenerCollection.reset( new ScChartListenerCollection( *this ) );
      pRefreshTimerControl.reset( new ScRefreshTimerControl );
  }
  else
  {
      pChartListenerCollection = nullptr;
  }
  pDBCollection.reset( new ScDBCollection(*this) );
  pSelectionAttr = nullptr;
  apTemporaryChartLock.reset( new ScTemporaryChartLock(this) );
  xColNameRanges = new ScRangePairList;
  xRowNameRanges = new ScRangePairList;
  ImplCreateOptions();
  // languages for a visible document are set by docshell later (from options)
  SetLanguage( ScGlobal::eLnge, ScGlobal::eLnge, ScGlobal::eLnge );

  aTrackIdle.SetInvokeHandler( LINK( this, ScDocument, TrackTimeHdl )::tools::detail::makeLink( ::tools::detail::castTo<ScDocument
 *>(this), &ScDocument::LinkStubTrackTimeHdl) );
213}

215sfx2::LinkManager* ScDocument::GetLinkManager()
216{
  return GetDocLinkManager().getLinkManager();
218}

220const sfx2::LinkManager* ScDocument::GetLinkManager() const
221{
  return GetDocLinkManager().getExistingLinkManager();
223}

225sc::DocumentLinkManager& ScDocument::GetDocLinkManager()
226{
  return *mpDocLinkMgr;
228}

230const sc::DocumentLinkManager& ScDocument::GetDocLinkManager() const
231{
  return const_cast<ScDocument*>(this)->GetDocLinkManager();
233}

235void ScDocument::SetStorageGrammar( formula::FormulaGrammar::Grammar eGram )
236{
  OSL_PRECOND(do { if (true && (!(eGram == formula::FormulaGrammar::
GRAM_ODFF || eGram == formula::FormulaGrammar::GRAM_PODF))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "240" ": "), "%s", "ScDocument::SetStorageGrammar: wrong storage grammar"
); } } while (false)
      eGram == formula::FormulaGrammar::GRAM_ODFF ||do { if (true && (!(eGram == formula::FormulaGrammar::
GRAM_ODFF || eGram == formula::FormulaGrammar::GRAM_PODF))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "240" ": "), "%s", "ScDocument::SetStorageGrammar: wrong storage grammar"
); } } while (false)
          eGram == formula::FormulaGrammar::GRAM_PODF,do { if (true && (!(eGram == formula::FormulaGrammar::
GRAM_ODFF || eGram == formula::FormulaGrammar::GRAM_PODF))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "240" ": "), "%s", "ScDocument::SetStorageGrammar: wrong storage grammar"
); } } while (false)
          "ScDocument::SetStorageGrammar: wrong storage grammar")do { if (true && (!(eGram == formula::FormulaGrammar::
GRAM_ODFF || eGram == formula::FormulaGrammar::GRAM_PODF))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "240" ": "), "%s", "ScDocument::SetStorageGrammar: wrong storage grammar"
); } } while (false);

  eStorageGrammar = eGram;
243}

245void ScDocument::SetDocVisible( bool bSet )
246{
  //  called from view ctor - only for a visible document,
  //  each new sheet's RTL flag is initialized from the locale
  bIsVisible = bSet;
250}

252sal_uInt32 ScDocument::GetDocumentID() const
253{
  const ScDocument* pThis = this;
  sal_uInt32 nCrc = rtl_crc32( 0, &pThis, sizeof(ScDocument*) );
  // the this pointer only might not be sufficient
  nCrc = rtl_crc32( nCrc, &mpShell, sizeof(SfxObjectShell*) );
  return nCrc;
259}

261void ScDocument::StartChangeTracking()
262{
  if (!pChangeTrack)
      pChangeTrack.reset( new ScChangeTrack( *this ) );
265}

267void ScDocument::EndChangeTracking()
268{
  pChangeTrack.reset();
270}

272void ScDocument::SetChangeTrack( std::unique_ptr<ScChangeTrack> pTrack )
273{
  OSL_ENSURE( &pTrack->GetDocument() == this, "SetChangeTrack: different documents" )do { if (true && (!(&pTrack->GetDocument() == this
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "274" ": "), "%s", "SetChangeTrack: different documents"
); } } while (false);
  if ( !pTrack || pTrack == pChangeTrack || &pTrack->GetDocument() != this )
      return ;
  EndChangeTracking();
  pChangeTrack = std::move(pTrack);
279}

281IMPL_LINK_NOARG(ScDocument, TrackTimeHdl, Timer *, void)void ScDocument::LinkStubTrackTimeHdl(void * instance, Timer *
 data) { return static_cast<ScDocument *>(instance)->
TrackTimeHdl(data); } void ScDocument::TrackTimeHdl(__attribute__
 ((unused)) Timer *)
282{
  if ( ScDdeLink::IsInUpdate() )      // do not nest
  {
      aTrackIdle.Start();            // try again later
  }
  else if (mpShell)                    // execute
  {
      TrackFormulas();
      mpShell->Broadcast( SfxHint( SfxHintId::ScDataChanged ) );

      if (!mpShell->IsModified())
      {
          mpShell->SetModified();
          SfxBindings* pBindings = GetViewBindings();
          if (pBindings)
          {
              pBindings->Invalidate( SID_SAVEDOC(5000 + 505) );
              pBindings->Invalidate( SID_DOC_MODIFIED(5000 + 584) );
          }
      }
  }
303}

305void ScDocument::SetExpandRefs( bool bVal )
306{
  bExpandRefs = bVal;
308}

310void ScDocument::StartTrackTimer()
311{
  if (!aTrackIdle.IsActive())        // do not postpone for forever
      aTrackIdle.Start();
314}

316void ScDocument::ClosingClipboardSource()
317{
  if (!bIsClip)
      return;

  ForgetNoteCaptions( ScRangeList( ScRange( 0,0,0, MaxCol(), MaxRow(), GetTableCount()-1)), true);
322}

324ScDocument::~ScDocument()
325{
  OSL_PRECOND( !bInLinkUpdate, "bInLinkUpdate in dtor" )do { if (true && (!(!bInLinkUpdate))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "326" ": "), "%s", "bInLinkUpdate in dtor"); } } while (
false);
1
Assuming field 'bInLinkUpdate' is true→
2
←
Taking true branch→
3
←
Loop condition is false.  Exiting loop→

  // Join any pending(recalc) threads in global threadpool
  comphelper::ThreadPool::getSharedOptimalPool().joinAll();

  bInDtorClear = true;

  // first of all disable all refresh timers by deleting the control
  if ( pRefreshTimerControl )
4
←
Taking true branch→
  {   // To be sure there isn't anything running do it with a protector,
      // this ensures also that nothing needs the control anymore.
      ScRefreshTimerProtector aProt( GetRefreshTimerControlAddress() );
      pRefreshTimerControl.reset();
  }

  mxFormulaParserPool.reset();
  // Destroy the external ref mgr instance here because it has a timer
  // which needs to be stopped before the app closes.
  pExternalRefMgr.reset();

  ScAddInAsync::RemoveDocument( this );
  ScAddInListener::RemoveDocument( this );
  pChartListenerCollection.reset();   // before pBASM because of potential Listener!

  ClearLookupCaches(); // before pBASM because of listeners

  // destroy BroadcastAreas first to avoid un-needed Single-EndListenings of Formula-Cells
  pBASM.reset();       // BroadcastAreaSlotMachine

  pUnoBroadcaster.reset();     // broadcasts SfxHintId::Dying again

  pUnoRefUndoList.reset();
  pUnoListenerCalls.reset();

  Clear( true );              // true = from destructor (needed for SdrModel::ClearModel)

  pValidationList.reset();
  pRangeName.reset();
  pDBCollection.reset();
  pSelectionAttr.reset();
  apTemporaryChartLock.reset();
  DeleteDrawLayer();
  mpPrinter.disposeAndClear();
  ImplDeleteOptions();
  pConsolidateDlgData.reset();
  pClipData.reset();
  pDetOpList.reset();                  // also deletes entries
  pChangeTrack.reset();
  mpEditEngine.reset();
  mpNoteEngine.reset();
  pChangeViewSettings.reset();         // and delete
  mpVirtualDevice_100th_mm.disposeAndClear();
5
←
Calling 'VclPtr::disposeAndClear'→

  pDPCollection.reset();
  mpAnonymousDBData.reset();

  // delete the EditEngine before destroying the mxPoolHelper
  pCacheFieldEditEngine.reset();

  if ( mxPoolHelper.is() && !bIsClip && !bIsUndo)
      mxPoolHelper->SourceDocumentGone();
  mxPoolHelper.clear();

  pScriptTypeData.reset();
  maNonThreaded.xRecursionHelper.reset();
  maThreadSpecific.xRecursionHelper.reset();

  pPreviewFont.reset();
  SAL_WARN_IF( pAutoNameCache, "sc.core", "AutoNameCache still set in dtor" )do { if (true && (pAutoNameCache)) { switch (sal_detail_log_report
(::SAL_DETAIL_LOG_LEVEL_WARN, "sc.core")) { case SAL_DETAIL_LOG_ACTION_IGNORE
: break; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail
::getResult( ::sal::detail::StreamStart() << "AutoNameCache still set in dtor"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"
), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "394" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "AutoNameCache still set in dtor"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "AutoNameCache still set in dtor"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "394" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "AutoNameCache still set in dtor") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "394" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "AutoNameCache still set in dtor"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "AutoNameCache still set in dtor"; ::sal::detail::log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.core"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "394" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

  mpFormulaGroupCxt.reset();
  // Purge unused items if the string pool will be still used (e.g. by undo history).
  if(mpCellStringPool.use_count() > 1)
      mpCellStringPool->purge();
  mpCellStringPool.reset();

  assert( pDelayedFormulaGrouping == nullptr )(static_cast <bool> (pDelayedFormulaGrouping == nullptr
) ? void (0) : __assert_fail ("pDelayedFormulaGrouping == nullptr"
, "/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
, 402, __extension__ __PRETTY_FUNCTION__));
  assert( pDelayedStartListeningFormulaCells.empty())(static_cast <bool> (pDelayedStartListeningFormulaCells
.empty()) ? void (0) : __assert_fail ("pDelayedStartListeningFormulaCells.empty()"
, "/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
, 403, __extension__ __PRETTY_FUNCTION__));
404}

406void ScDocument::InitClipPtrs( ScDocument* pSourceDoc )
407{
  OSL_ENSURE(bIsClip, "InitClipPtrs and not bIsClip")do { if (true && (!(bIsClip))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "408" ": "), "%s", "InitClipPtrs and not bIsClip"); } } while
 (false);

  ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);

  pValidationList.reset();

  Clear();

  SharePooledResources(pSourceDoc);

  //  conditional Formats / validations
  // TODO: Copy Templates?
  const ScValidationDataList* pSourceValid = pSourceDoc->pValidationList.get();
  if ( pSourceValid )
      pValidationList.reset(new ScValidationDataList(*this, *pSourceValid));

  // store Links in Stream
  pClipData.reset();
  if (pSourceDoc->GetDocLinkManager().hasDdeLinks())
  {
      pClipData.reset( new SvMemoryStream );
      pSourceDoc->SaveDdeLinks(*pClipData);
  }

  // Options pointers exist (ImplCreateOptions) for any document.
  // Must be copied for correct results in OLE objects (#i42666#).
  SetDocOptions( pSourceDoc->GetDocOptions() );
  SetViewOptions( pSourceDoc->GetViewOptions() );
436}

438SvNumberFormatter* ScDocument::GetFormatTable() const
439{
  assert(!IsThreadedGroupCalcInProgress())(static_cast <bool> (!IsThreadedGroupCalcInProgress()) ?
 void (0) : __assert_fail ("!IsThreadedGroupCalcInProgress()"
, "/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
, 440, __extension__ __PRETTY_FUNCTION__));
  return mxPoolHelper->GetFormTable();
442}

444SfxItemPool* ScDocument::GetEditPool() const
445{
  return mxPoolHelper->GetEditPool();
447}

449SfxItemPool* ScDocument::GetEnginePool() const
450{
  return mxPoolHelper->GetEnginePool();
452}

454ScFieldEditEngine& ScDocument::GetEditEngine()
455{
  if ( !mpEditEngine )
  {
      mpEditEngine.reset( new ScFieldEditEngine(this, GetEnginePool(), GetEditPool()) );
      mpEditEngine->SetUpdateMode( false );
      mpEditEngine->EnableUndo( false );
      mpEditEngine->SetRefMapMode(MapMode(MapUnit::Map100thMM));
      ApplyAsianEditSettings( *mpEditEngine );
  }
  return *mpEditEngine;
465}

467ScNoteEditEngine& ScDocument::GetNoteEngine()
468{
  if ( !mpNoteEngine )
  {
      ScMutationGuard aGuard(*this, ScMutationGuardFlags::CORE);
      mpNoteEngine.reset( new ScNoteEditEngine( GetEnginePool(), GetEditPool() ) );
      mpNoteEngine->SetUpdateMode( false );
      mpNoteEngine->EnableUndo( false );
      mpNoteEngine->SetRefMapMode(MapMode(MapUnit::Map100thMM));
      ApplyAsianEditSettings( *mpNoteEngine );
      const SfxItemSet& rItemSet = GetDefPattern()->GetItemSet();
      std::unique_ptr<SfxItemSet> pEEItemSet(new SfxItemSet( mpNoteEngine->GetEmptyItemSet() ));
      ScPatternAttr::FillToEditItemSet( *pEEItemSet, rItemSet );
      mpNoteEngine->SetDefaults( std::move(pEEItemSet) );      // edit engine takes ownership
  }
  return *mpNoteEngine;
483}

485void ScDocument::ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks )
486{
  if (bIsClip)
  {
      InitClipPtrs(pSourceDoc);

      for (SCTAB i = 0; i < static_cast<SCTAB>(pSourceDoc->maTabs.size()); i++)
          if (pSourceDoc->maTabs[i])
              if (!pMarks || pMarks->GetTableSelect(i))
              {
                  OUString aString = pSourceDoc->maTabs[i]->GetName();
                  if ( i < static_cast<SCTAB>(maTabs.size()) )
                  {
                      maTabs[i].reset( new ScTable(*this, i, aString) );

                  }
                  else
                  {
                      if( i > static_cast<SCTAB>(maTabs.size()) )
                      {
                          maTabs.resize(i);
                      }
                      maTabs.emplace_back(new ScTable(*this, i, aString));
                  }
                  maTabs[i]->SetLayoutRTL( pSourceDoc->maTabs[i]->IsLayoutRTL() );
              }
  }
  else
  {
      OSL_FAIL("ResetClip")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "514" ": "), "%s", "ResetClip"); } } while (false);
  }
516}

518void ScDocument::ResetClip( ScDocument* pSourceDoc, SCTAB nTab )
519{
  if (bIsClip)
  {
      InitClipPtrs(pSourceDoc);
      if (nTab >= static_cast<SCTAB>(maTabs.size()))
      {
          maTabs.resize(nTab+1);
      }
      maTabs[nTab].reset( new ScTable(*this, nTab, "baeh") );
      if (nTab < static_cast<SCTAB>(pSourceDoc->maTabs.size()) && pSourceDoc->maTabs[nTab])
          maTabs[nTab]->SetLayoutRTL( pSourceDoc->maTabs[nTab]->IsLayoutRTL() );
  }
  else
  {
      OSL_FAIL("ResetClip")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "533" ": "), "%s", "ResetClip"); } } while (false);
  }
535}

537void ScDocument::EnsureTable( SCTAB nTab )
538{
  bool bExtras = !bIsUndo;        // Column-Widths, Row-Heights, Flags
  if (o3tl::make_unsigned(nTab) >= maTabs.size())
      maTabs.resize(nTab+1);

  if (!maTabs[nTab])
      maTabs[nTab].reset( new ScTable(*this, nTab, "temp", bExtras, bExtras) );
545}

547ScRefCellValue ScDocument::GetRefCellValue( const ScAddress& rPos )
548{
  if (!TableExists(rPos.Tab()))
      return ScRefCellValue(); // empty

  return maTabs[rPos.Tab()]->GetRefCellValue(rPos.Col(), rPos.Row());
553}

555ScRefCellValue ScDocument::GetRefCellValue( const ScAddress& rPos, sc::ColumnBlockPosition& rBlockPos )
556{
  if (!TableExists(rPos.Tab()))
      return ScRefCellValue(); // empty

  return maTabs[rPos.Tab()]->GetRefCellValue(rPos.Col(), rPos.Row(), rBlockPos);
561}

563svl::SharedStringPool& ScDocument::GetSharedStringPool()
564{
  return *mpCellStringPool;
566}

568const svl::SharedStringPool& ScDocument::GetSharedStringPool() const
569{
  return *mpCellStringPool;
571}

573bool ScDocument::GetPrintArea( SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow,
                              bool bNotes ) const
575{
  if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
  {
      bool bAny = maTabs[nTab]->GetPrintArea( rEndCol, rEndRow, bNotes );
      if (mpDrawLayer)
      {
          ScRange aDrawRange(0,0,nTab, MaxCol(),MaxRow(),nTab);
          if (DrawGetPrintArea( aDrawRange, true, true ))
          {
              if (aDrawRange.aEnd.Col()>rEndCol) rEndCol=aDrawRange.aEnd.Col();
              if (aDrawRange.aEnd.Row()>rEndRow) rEndRow=aDrawRange.aEnd.Row();
              bAny = true;
          }
      }
      return bAny;
  }

  rEndCol = 0;
  rEndRow = 0;
  return false;
595}

597bool ScDocument::GetPrintAreaHor( SCTAB nTab, SCROW nStartRow, SCROW nEndRow,
                                      SCCOL& rEndCol ) const
599{
  if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
  {
      bool bAny = maTabs[nTab]->GetPrintAreaHor( nStartRow, nEndRow, rEndCol );
      if (mpDrawLayer)
      {
          ScRange aDrawRange(0,nStartRow,nTab, MaxCol(),nEndRow,nTab);
          if (DrawGetPrintArea( aDrawRange, true, false ))
          {
              if (aDrawRange.aEnd.Col()>rEndCol) rEndCol=aDrawRange.aEnd.Col();
              bAny = true;
          }
      }
      return bAny;
  }

  rEndCol = 0;
  return false;
617}

619bool ScDocument::GetPrintAreaVer( SCTAB nTab, SCCOL nStartCol, SCCOL nEndCol,
                                      SCROW& rEndRow, bool bNotes ) const
621{
  if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
  {
      bool bAny = maTabs[nTab]->GetPrintAreaVer( nStartCol, nEndCol, rEndRow, bNotes );
      if (mpDrawLayer)
      {
          ScRange aDrawRange(nStartCol,0,nTab, nEndCol,MaxRow(),nTab);
          if (DrawGetPrintArea( aDrawRange, false, true ))
          {
              if (aDrawRange.aEnd.Row()>rEndRow) rEndRow=aDrawRange.aEnd.Row();
              bAny = true;
          }
      }
      return bAny;
  }

  rEndRow = 0;
  return false;
639}

641bool ScDocument::GetDataStart( SCTAB nTab, SCCOL& rStartCol, SCROW& rStartRow ) const
642{
  if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()) && maTabs[nTab])
  {
      bool bAny = maTabs[nTab]->GetDataStart( rStartCol, rStartRow );
      if (mpDrawLayer)
      {
          ScRange aDrawRange(0,0,nTab, MaxCol(),MaxRow(),nTab);
          if (DrawGetPrintArea( aDrawRange, true, true ))
          {
              if (aDrawRange.aStart.Col()<rStartCol) rStartCol=aDrawRange.aStart.Col();
              if (aDrawRange.aStart.Row()<rStartRow) rStartRow=aDrawRange.aStart.Row();
              bAny = true;
          }
      }
      return bAny;
  }

  rStartCol = 0;
  rStartRow = 0;
  return false;
662}

664void ScDocument::GetTiledRenderingArea(SCTAB nTab, SCCOL& rEndCol, SCROW& rEndRow) const
665{
  bool bHasPrintArea = GetPrintArea(nTab, rEndCol, rEndRow, false);

  // we need some reasonable minimal document size
  ScViewData* pViewData = ScDocShell::GetViewData();
  if (!pViewData)
  {
      if (!bHasPrintArea)
      {
          rEndCol = 20;
          rEndRow = 50;
      }
      else
      {
          rEndCol += 20;
          rEndRow += 50;
      }
  }
  else if (!bHasPrintArea)
  {
      rEndCol = pViewData->GetMaxTiledCol();
      rEndRow = pViewData->GetMaxTiledRow();
  }
  else
  {
      rEndCol = std::max(rEndCol, pViewData->GetMaxTiledCol());
      rEndRow = std::max(rEndRow, pViewData->GetMaxTiledRow());
  }
693}

695bool ScDocument::MoveTab( SCTAB nOldPos, SCTAB nNewPos, ScProgress* pProgress )
696{
  if (nOldPos == nNewPos)
      return false;

  SCTAB nTabCount = static_cast<SCTAB>(maTabs.size());
  if(nTabCount < 2)
      return false;

  bool bValid = false;
  if (ValidTab(nOldPos) && nOldPos < nTabCount )
  {
      if (maTabs[nOldPos])
      {
          sc::AutoCalcSwitch aACSwitch(*this, false);

          SetNoListening( true );
          if (nNewPos == SC_TAB_APPEND || nNewPos >= nTabCount)
              nNewPos = nTabCount-1;

          // Update Reference
          // TODO: combine with UpdateReference!

          sc::RefUpdateMoveTabContext aCxt( *this, nOldPos, nNewPos);

          SCTAB nDz = nNewPos - nOldPos;
          ScRange aSourceRange( 0,0,nOldPos, MaxCol(),MaxRow(),nOldPos );
          if (pRangeName)
              pRangeName->UpdateMoveTab(aCxt);

          pDBCollection->UpdateMoveTab( nOldPos, nNewPos );
          xColNameRanges->UpdateReference( URM_REORDER, this, aSourceRange, 0,0,nDz );
          xRowNameRanges->UpdateReference( URM_REORDER, this, aSourceRange, 0,0,nDz );
          if (pDPCollection)
              pDPCollection->UpdateReference( URM_REORDER, aSourceRange, 0,0,nDz );
          if (pDetOpList)
              pDetOpList->UpdateReference( this, URM_REORDER, aSourceRange, 0,0,nDz );
          UpdateChartRef( URM_REORDER,
                  0,0,nOldPos, MaxCol(),MaxRow(),nOldPos, 0,0,nDz );
          UpdateRefAreaLinks( URM_REORDER, aSourceRange, 0,0,nDz );
          if ( pValidationList )
              pValidationList->UpdateMoveTab(aCxt);
          if ( pUnoBroadcaster )
              pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_REORDER,
                          aSourceRange, 0,0,nDz ) );

          ScTableUniquePtr pSaveTab = std::move(maTabs[nOldPos]);
          maTabs.erase(maTabs.begin()+nOldPos);
          maTabs.insert(maTabs.begin()+nNewPos, std::move(pSaveTab));
          for (SCTAB i = 0; i < nTabCount; i++)
              if (maTabs[i])
                  maTabs[i]->UpdateMoveTab(aCxt, i, pProgress);
          for (auto& rxTab : maTabs)
              if (rxTab)
                  rxTab->UpdateCompile();
          SetNoListening( false );
          StartAllListeners();

          sc::SetFormulaDirtyContext aFormulaDirtyCxt;
          SetAllFormulasDirty(aFormulaDirtyCxt);

          if (mpDrawLayer)
              mpDrawLayer->ScMovePage( static_cast<sal_uInt16>(nOldPos), static_cast<sal_uInt16>(nNewPos) );

          bValid = true;
      }
  }
  return bValid;
763}

765bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData* pOnlyMarked )
766{
  if (SC_TAB_APPEND == nNewPos  || nNewPos >= static_cast<SCTAB>(maTabs.size()))
      nNewPos = static_cast<SCTAB>(maTabs.size());
  OUString aName;
  GetName(nOldPos, aName);

  //  check first if Prefix is valid; if not, then only avoid duplicates
  bool bPrefix = ValidTabName( aName );
  OSL_ENSURE(bPrefix, "invalid table name")do { if (true && (!(bPrefix))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "774" ": "), "%s", "invalid table name"); } } while (false
);
  SCTAB nDummy;

  CreateValidTabName(aName);

  bool bValid;
  if (bPrefix)
      bValid = ValidNewTabName(aName);
  else
      bValid = !GetTable( aName, nDummy );

  sc::AutoCalcSwitch aACSwitch(*this, false);
  sc::RefUpdateInsertTabContext aCxt( *this, nNewPos, 1);

  if (bValid)
  {
      if (nNewPos >= static_cast<SCTAB>(maTabs.size()))
      {
          nNewPos = static_cast<SCTAB>(maTabs.size());
          maTabs.emplace_back(new ScTable(*this, nNewPos, aName));
      }
      else
      {
          if (ValidTab(nNewPos) && (nNewPos < static_cast<SCTAB>(maTabs.size())))
          {
              SetNoListening( true );

              ScRange aRange( 0,0,nNewPos, MaxCol(),MaxRow(),MAXTAB );
              xColNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
              xRowNameRanges->UpdateReference( URM_INSDEL, this, aRange, 0,0,1 );
              if (pRangeName)
                  pRangeName->UpdateInsertTab(aCxt);

              pDBCollection->UpdateReference(
                                  URM_INSDEL, 0,0,nNewPos, MaxCol(),MaxRow(),MAXTAB, 0,0,1 );
              if (pDPCollection)
                  pDPCollection->UpdateReference( URM_INSDEL, aRange, 0,0,1 );
              if (pDetOpList)
                  pDetOpList->UpdateReference( this, URM_INSDEL, aRange, 0,0,1 );
              UpdateChartRef( URM_INSDEL, 0,0,nNewPos, MaxCol(),MaxRow(),MAXTAB, 0,0,1 );
              UpdateRefAreaLinks( URM_INSDEL, aRange, 0,0,1 );
              if ( pUnoBroadcaster )
                  pUnoBroadcaster->Broadcast( ScUpdateRefHint( URM_INSDEL, aRange, 0,0,1 ) );

              for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
                  if (*it && it != (maTabs.begin() + nOldPos))
                      (*it)->UpdateInsertTab(aCxt);
              if (nNewPos <= nOldPos)
                  nOldPos++;
              maTabs.emplace(maTabs.begin() + nNewPos, new ScTable(*this, nNewPos, aName));
              bValid = true;
              for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
                  if (*it && it != maTabs.begin()+nOldPos && it != maTabs.begin() + nNewPos)
                      (*it)->UpdateCompile();
              SetNoListening( false );
              sc::StartListeningContext aSLCxt(*this);
              for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
                  if (*it && it != maTabs.begin()+nOldPos && it != maTabs.begin()+nNewPos)
                      (*it)->StartListeners(aSLCxt, true);

              if (pValidationList)
                  pValidationList->UpdateInsertTab(aCxt);
         }
          else
              bValid = false;
      }
  }

  if (bValid)
  {
      SetNoListening( true );     // not yet at CopyToTable/Insert

      const bool bGlobalNamesToLocal = true;
      const SCTAB nRealOldPos = (nNewPos < nOldPos) ? nOldPos - 1 : nOldPos;
      const ScRangeName* pNames = GetRangeName( nOldPos);
      if (pNames)
          pNames->CopyUsedNames( nOldPos, nRealOldPos, nNewPos, *this, *this, bGlobalNamesToLocal);
      GetRangeName()->CopyUsedNames( -1, nRealOldPos, nNewPos, *this, *this, bGlobalNamesToLocal);

      sc::CopyToDocContext aCopyDocCxt(*this);
      maTabs[nOldPos]->CopyToTable(aCopyDocCxt, 0, 0, MaxCol(), MaxRow(), InsertDeleteFlags::ALL,
              (pOnlyMarked != nullptr), maTabs[nNewPos].get(), pOnlyMarked,
              false /*bAsLink*/, true /*bColRowFlags*/, bGlobalNamesToLocal, false /*bCopyCaptions*/ );
      maTabs[nNewPos]->SetTabBgColor(maTabs[nOldPos]->GetTabBgColor());

      SCTAB nDz = nNewPos - nOldPos;
      sc::RefUpdateContext aRefCxt(*this);
      aRefCxt.meMode = URM_COPY;
      aRefCxt.maRange = ScRange(0, 0, nNewPos, MaxCol(), MaxRow(), nNewPos);
      aRefCxt.mnTabDelta = nDz;
      maTabs[nNewPos]->UpdateReference(aRefCxt);

      maTabs[nNewPos]->UpdateInsertTabAbs(nNewPos); // move all paragraphs up by one!!
      maTabs[nOldPos]->UpdateInsertTab(aCxt);

      maTabs[nOldPos]->UpdateCompile();
      maTabs[nNewPos]->UpdateCompile( true ); //  maybe already compiled in Clone, but used names need recompilation
      SetNoListening( false );
      sc::StartListeningContext aSLCxt(*this);
      maTabs[nOldPos]->StartListeners(aSLCxt, true);
      maTabs[nNewPos]->StartListeners(aSLCxt, true);

      sc::SetFormulaDirtyContext aFormulaDirtyCxt;
      SetAllFormulasDirty(aFormulaDirtyCxt);

      if (mpDrawLayer) //  Skip cloning Note caption object
          // page is already created in ScTable ctor
          mpDrawLayer->ScCopyPage( static_cast<sal_uInt16>(nOldPos), static_cast<sal_uInt16>(nNewPos) );

      if (pDPCollection)
          pDPCollection->CopyToTab(nOldPos, nNewPos);

      maTabs[nNewPos]->SetPageStyle( maTabs[nOldPos]->GetPageStyle() );
      maTabs[nNewPos]->SetPendingRowHeights( maTabs[nOldPos]->IsPendingRowHeights() );

      // Copy the custom print range if exists.
      maTabs[nNewPos]->CopyPrintRange(*maTabs[nOldPos]);

      // Copy the RTL settings
      maTabs[nNewPos]->SetLayoutRTL(maTabs[nOldPos]->IsLayoutRTL());
      maTabs[nNewPos]->SetLoadingRTL(maTabs[nOldPos]->IsLoadingRTL());

      // Finally copy the note captions, which need
      // 1. the updated source ScColumn::nTab members if nNewPos <= nOldPos
      // 2. row heights and column widths of the destination
      // 3. RTL settings of the destination
      maTabs[nOldPos]->CopyCaptionsToTable( 0, 0, MaxCol(), MaxRow(), maTabs[nNewPos].get(), true /*bCloneCaption*/);
  }

  return bValid;
904}

906sal_uLong ScDocument::TransferTab( ScDocument& rSrcDoc, SCTAB nSrcPos,
                              SCTAB nDestPos, bool bInsertNew,
                              bool bResultsOnly )
909{
  sal_uLong nRetVal = 1;                  // 0 => error 1 = ok
                                          // 3 => NameBox
                                          // 4 => both

  if (rSrcDoc.mpShell->GetMedium())
  {
      rSrcDoc.maFileURL = rSrcDoc.mpShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::ToIUri);
      // for unsaved files use the title name and adjust during save of file
      if (rSrcDoc.maFileURL.isEmpty())
          rSrcDoc.maFileURL = rSrcDoc.mpShell->GetName();
  }
  else
  {
      rSrcDoc.maFileURL = rSrcDoc.mpShell->GetName();
  }

  bool bValid = true;
  if (bInsertNew)             // re-insert
  {
      OUString aName;
      rSrcDoc.GetName(nSrcPos, aName);
      CreateValidTabName(aName);
      bValid = InsertTab(nDestPos, aName);

      // Copy the RTL settings
      maTabs[nDestPos]->SetLayoutRTL(rSrcDoc.maTabs[nSrcPos]->IsLayoutRTL());
      maTabs[nDestPos]->SetLoadingRTL(rSrcDoc.maTabs[nSrcPos]->IsLoadingRTL());
  }
  else                        // replace existing tables
  {
      if (ValidTab(nDestPos) && nDestPos < static_cast<SCTAB>(maTabs.size()) && maTabs[nDestPos])
      {
          maTabs[nDestPos]->DeleteArea( 0,0, MaxCol(),MaxRow(), InsertDeleteFlags::ALL );
      }
      else
          bValid = false;
  }

  if (bValid)
  {
      bool bOldAutoCalcSrc = false;
      bool bOldAutoCalc = GetAutoCalc();
      SetAutoCalc( false );   // avoid repeated calculations
      SetNoListening( true );
      if ( bResultsOnly )
      {
          bOldAutoCalcSrc = rSrcDoc.GetAutoCalc();
          rSrcDoc.SetAutoCalc( true );   // in case something needs calculation
      }

      {
          NumFmtMergeHandler aNumFmtMergeHdl(*this, rSrcDoc);

          sc::CopyToDocContext aCxt(*this);
          nDestPos = std::min(nDestPos, static_cast<SCTAB>(GetTableCount() - 1));
          {   // scope for bulk broadcast
              ScBulkBroadcast aBulkBroadcast( pBASM.get(), SfxHintId::ScDataChanged);
              if (!bResultsOnly)
              {
                  const bool bGlobalNamesToLocal = false;
                  const ScRangeName* pNames = rSrcDoc.GetRangeName( nSrcPos);
                  if (pNames)
                      pNames->CopyUsedNames( nSrcPos, nSrcPos, nDestPos, rSrcDoc, *this, bGlobalNamesToLocal);
                  rSrcDoc.GetRangeName()->CopyUsedNames( -1, nSrcPos, nDestPos, rSrcDoc, *this, bGlobalNamesToLocal);
              }
              rSrcDoc.maTabs[nSrcPos]->CopyToTable(aCxt, 0, 0, MaxCol(), MaxRow(),
                      ( bResultsOnly ? InsertDeleteFlags::ALL & ~InsertDeleteFlags::FORMULA : InsertDeleteFlags::ALL),
                      false, maTabs[nDestPos].get(), /*pMarkData*/nullptr, /*bAsLink*/false, /*bColRowFlags*/true,
                      /*bGlobalNamesToLocal*/false, /*bCopyCaptions*/true );
          }
      }
      maTabs[nDestPos]->SetTabNo(nDestPos);
      maTabs[nDestPos]->SetTabBgColor(rSrcDoc.maTabs[nSrcPos]->GetTabBgColor());

      if ( !bResultsOnly )
      {
          sc::RefUpdateContext aRefCxt(*this);
          aRefCxt.meMode = URM_COPY;
          aRefCxt.maRange = ScRange(0, 0, nDestPos, MaxCol(), MaxRow(), nDestPos);
          aRefCxt.mnTabDelta = nDestPos - nSrcPos;
          maTabs[nDestPos]->UpdateReference(aRefCxt);

          // Readjust self-contained absolute references to this sheet
          maTabs[nDestPos]->TestTabRefAbs(nSrcPos);
          sc::CompileFormulaContext aFormulaCxt(*this);
          maTabs[nDestPos]->CompileAll(aFormulaCxt);
      }

      SetNoListening( false );
      if ( !bResultsOnly )
      {
          sc::StartListeningContext aSLCxt(*this);
          maTabs[nDestPos]->StartListeners(aSLCxt, true);
      }
      SetDirty( ScRange( 0, 0, nDestPos, MaxCol(), MaxRow(), nDestPos), false);

      if ( bResultsOnly )
          rSrcDoc.SetAutoCalc( bOldAutoCalcSrc );
      SetAutoCalc( bOldAutoCalc );

      //  copy Drawing

      if (bInsertNew)
          TransferDrawPage( rSrcDoc, nSrcPos, nDestPos );

      maTabs[nDestPos]->SetPendingRowHeights( rSrcDoc.maTabs[nSrcPos]->IsPendingRowHeights() );
  }
  if (!bValid)
      nRetVal = 0;
  bool bVbaEnabled = IsInVBAMode();

  if ( bVbaEnabled  )
  {
      SfxObjectShell* pSrcShell = rSrcDoc.GetDocumentShell();
      if ( pSrcShell )
      {
          OUString aLibName("Standard");
          const BasicManager *pBasicManager = pSrcShell->GetBasicManager();
          if (pBasicManager && !pBasicManager->GetName().isEmpty())
          {
              aLibName = pSrcShell->GetBasicManager()->GetName();
          }
          OUString sSource;
          uno::Reference< script::XLibraryContainer > xLibContainer = pSrcShell->GetBasicContainer();
          uno::Reference< container::XNameContainer > xLib;
          if( xLibContainer.is() )
          {
              uno::Any aLibAny = xLibContainer->getByName(aLibName);
              aLibAny >>= xLib;
          }

          if( xLib.is() )
          {
              OUString sSrcCodeName;
              rSrcDoc.GetCodeName( nSrcPos, sSrcCodeName );
              OUString sRTLSource;
              xLib->getByName( sSrcCodeName ) >>= sRTLSource;
              sSource = sRTLSource;
          }
          VBA_InsertModule( *this, nDestPos, sSource );
      }
  }

  return nRetVal;
1054}

1056void ScDocument::SetError( SCCOL nCol, SCROW nRow, SCTAB nTab, const FormulaError nError)
1057{
  if (ValidTab(nTab) && nTab < static_cast<SCTAB>(maTabs.size()))
      if (maTabs[nTab])
          maTabs[nTab]->SetError( nCol, nRow, nError );
1061}

1063void ScDocument::SetFormula(
  const ScAddress& rPos, const ScTokenArray& rArray )
1065{
  if (!TableExists(rPos.Tab()))
      return;

  maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rArray, formula::FormulaGrammar::GRAM_DEFAULT);
1070}

1072void ScDocument::SetFormula(
  const ScAddress& rPos, const OUString& rFormula, formula::FormulaGrammar::Grammar eGram )
1074{
  if (!TableExists(rPos.Tab()))
      return;

  maTabs[rPos.Tab()]->SetFormula(rPos.Col(), rPos.Row(), rFormula, eGram);
1079}

1081ScFormulaCell* ScDocument::SetFormulaCell( const ScAddress& rPos, ScFormulaCell* pCell )
1082{
  if (!TableExists(rPos.Tab()))
  {
      delete pCell;
      return nullptr;
  }

  return maTabs[rPos.Tab()]->SetFormulaCell(rPos.Col(), rPos.Row(), pCell);
1090}

1092bool ScDocument::SetFormulaCells( const ScAddress& rPos, std::vector<ScFormulaCell*>& rCells )
1093{
  if (rCells.empty())
      return false;

  ScTable* pTab = FetchTable(rPos.Tab());
  if (!pTab)
      return false;

  return pTab->SetFormulaCells(rPos.Col(), rPos.Row(), rCells);
1102}

1104void ScDocument::SetConsolidateDlgData( std::unique_ptr<ScConsolidateParam> pData )
1105{
  pConsolidateDlgData = std::move(pData);
1107}

1109void ScDocument::SetChangeViewSettings(const ScChangeViewSettings& rNew)
1110{
  if (pChangeViewSettings==nullptr)
      pChangeViewSettings.reset( new ScChangeViewSettings );

  *pChangeViewSettings=rNew;
1115}

1117std::unique_ptr<ScFieldEditEngine> ScDocument::CreateFieldEditEngine()
1118{
  std::unique_ptr<ScFieldEditEngine> pNewEditEngine;
  if (!pCacheFieldEditEngine)
  {
      pNewEditEngine.reset( new ScFieldEditEngine(
          this, GetEnginePool(), GetEditPool(), false) );
  }
  else
  {
      if ( !bImportingXML )
      {
          // #i66209# previous use might not have restored update mode,
          // ensure same state as for a new EditEngine (UpdateMode = true)
          if ( !pCacheFieldEditEngine->GetUpdateMode() )
              pCacheFieldEditEngine->SetUpdateMode(true);
      }

      pNewEditEngine = std::move(pCacheFieldEditEngine);
  }
  return pNewEditEngine;
1138}

1140void ScDocument::DisposeFieldEditEngine(std::unique_ptr<ScFieldEditEngine>& rpEditEngine)
1141{
  if (!pCacheFieldEditEngine && rpEditEngine)
  {
      pCacheFieldEditEngine = std::move( rpEditEngine );
      pCacheFieldEditEngine->Clear();
  }
  else
      rpEditEngine.reset();
1149}

1151ScLookupCache & ScDocument::GetLookupCache( const ScRange & rRange, ScInterpreterContext* pContext )
1152{
  ScLookupCache* pCache = nullptr;
  if (!pContext->mxScLookupCache)
      pContext->mxScLookupCache.reset(new ScLookupCacheMap);
  ScLookupCacheMap* pCacheMap = pContext->mxScLookupCache.get();
  // insert with temporary value to avoid doing two lookups
  auto [findIt, bInserted] = pCacheMap->aCacheMap.emplace(rRange, nullptr);
  if (bInserted)
  {
      findIt->second = std::make_unique<ScLookupCache>(this, rRange, *pCacheMap);
      pCache = findIt->second.get();
      // The StartListeningArea() call is not thread-safe, as all threads
      // would access the same SvtBroadcaster.
      osl::MutexGuard guard( mScLookupMutex );
      StartListeningArea(rRange, false, pCache);
  }
  else
      pCache = (*findIt).second.get();

  return *pCache;
1172}

1174void ScDocument::RemoveLookupCache( ScLookupCache & rCache )
1175{
  // Data changes leading to this should never happen during calculation (they are either
  // a result of user input or recalc). If it turns out this can be the case, locking is needed
  // here and also in ScLookupCache::Notify().
  assert(!IsThreadedGroupCalcInProgress())(static_cast <bool> (!IsThreadedGroupCalcInProgress()) ?
 void (0) : __assert_fail ("!IsThreadedGroupCalcInProgress()"
, "/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
, 1179, __extension__ __PRETTY_FUNCTION__));
  auto & cacheMap = rCache.getCacheMap();
  auto it(cacheMap.aCacheMap.find(rCache.getRange()));
  if (it != cacheMap.aCacheMap.end())
  {
      ScLookupCache* pCache = (*it).second.release();
      cacheMap.aCacheMap.erase(it);
      assert(!IsThreadedGroupCalcInProgress())(static_cast <bool> (!IsThreadedGroupCalcInProgress()) ?
 void (0) : __assert_fail ("!IsThreadedGroupCalcInProgress()"
, "/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
, 1186, __extension__ __PRETTY_FUNCTION__)); // EndListeningArea() is not thread-safe
      EndListeningArea(pCache->getRange(), false, &rCache);
      return;
  }
  OSL_FAIL( "ScDocument::RemoveLookupCache: range not found in hash map")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
 ":" "1190" ": "), "%s", "ScDocument::RemoveLookupCache: range not found in hash map"
); } } while (false);
1191}

1193void ScDocument::ClearLookupCaches()
1194{
  assert(!IsThreadedGroupCalcInProgress())(static_cast <bool> (!IsThreadedGroupCalcInProgress()) ?
 void (0) : __assert_fail ("!IsThreadedGroupCalcInProgress()"
, "/home/maarten/src/libreoffice/core/sc/source/core/data/documen2.cxx"
, 1195, __extension__ __PRETTY_FUNCTION__));
  GetNonThreadedContext().mxScLookupCache.reset();
  // Clear lookup cache in all interpreter-contexts in the (threaded/non-threaded) pools.
  ScInterpreterContextPool::ClearLookupCaches();
1199}

1201bool ScDocument::IsCellInChangeTrack(const ScAddress &cell,Color *pColCellBorder)
1202{
  ScChangeTrack* pTrack = GetChangeTrack();
  ScChangeViewSettings* pSettings = GetChangeViewSettings();
  if ( !pTrack || !pTrack->GetFirst() || !pSettings || !pSettings->ShowChanges() )
      return false;           // missing or turned-off
  ScActionColorChanger aColorChanger(*pTrack);
  //  Clipping happens from outside
  //! TODO: without Clipping; only paint affected cells ??!??!?
  const ScChangeAction* pAction = pTrack->GetFirst();
  while (pAction)
  {
      if ( pAction->IsVisible() )
      {
          ScChangeActionType eType = pAction->GetType();
          const ScBigRange& rBig = pAction->GetBigRange();
          if ( rBig.aStart.Tab() == cell.Tab())
          {
              ScRange aRange = rBig.MakeRange();
              if ( eType == SC_CAT_DELETE_ROWS )
                  aRange.aEnd.SetRow( aRange.aStart.Row() );
              else if ( eType == SC_CAT_DELETE_COLS )
                  aRange.aEnd.SetCol( aRange.aStart.Col() );
              if (ScViewUtil::IsActionShown( *pAction, *pSettings, *this ) )
              {
                  if (aRange.In(cell))
                  {
                      if (pColCellBorder != nullptr)
                      {
                          aColorChanger.Update( *pAction );
                          Color aColor( aColorChanger.GetColor() );
                          *pColCellBorder = aColor;
                      }
                      return true;
                  }
              }
          }
          if ( eType == SC_CAT_MOVE &&
              static_cast<const ScChangeActionMove*>(pAction)->
              GetFromRange().aStart.Tab() == cell.Col() )
          {
              ScRange aRange = static_cast<const ScChangeActionMove*>(pAction)->
                  GetFromRange().MakeRange();
              if (ScViewUtil::IsActionShown( *pAction, *pSettings, *this ) )
              {
                  if (aRange.In(cell))
                  {
                      if (pColCellBorder != nullptr)
                      {
                          aColorChanger.Update( *pAction );
                          Color aColor( aColorChanger.GetColor() );
                          *pColCellBorder = aColor;
                      }
                      return true;
                  }
              }
          }
      }
      pAction = pAction->GetNext();
  }
  return false;
1262}

1264void ScDocument::GetCellChangeTrackNote( const ScAddress &aCellPos, OUString &aTrackText,bool &bLeftEdge)
1265{
  aTrackText.clear();
  //  Change-Tracking
  ScChangeTrack* pTrack = GetChangeTrack();
  ScChangeViewSettings* pSettings = GetChangeViewSettings();
  if ( !(pTrack && pTrack->GetFirst() && pSettings && pSettings->ShowChanges()))
      return;

  const ScChangeAction* pFound = nullptr;
  const ScChangeAction* pFoundContent = nullptr;
  const ScChangeAction* pFoundMove = nullptr;
  const ScChangeAction* pAction = pTrack->GetFirst();
  while (pAction)
  {
      if ( pAction->IsVisible() &&
           ScViewUtil::IsActionShown( *pAction, *pSettings, *this ) )
      {
          ScChangeActionType eType = pAction->GetType();
          const ScBigRange& rBig = pAction->GetBigRange();
          if ( rBig.aStart.Tab() == aCellPos.Tab())
          {
              ScRange aRange = rBig.MakeRange();
              if ( eType == SC_CAT_DELETE_ROWS )
                  aRange.aEnd.SetRow( aRange.aStart.Row() );
              else if ( eType == SC_CAT_DELETE_COLS )
                  aRange.aEnd.SetCol( aRange.aStart.Col() );
              if ( aRange.In( aCellPos ) )
              {
                  pFound = pAction;       // the last wins
                  switch ( eType )
                  {
                      case SC_CAT_CONTENT :
                          pFoundContent = pAction;
                      break;
                      case SC_CAT_MOVE :
                          pFoundMove = pAction;
                      break;
                      default:
                          break;
                  }
              }
          }
          if ( eType == SC_CAT_MOVE )
          {
              ScRange aRange =
                  static_cast<const ScChangeActionMove*>(pAction)->
                  GetFromRange().MakeRange();
              if ( aRange.In( aCellPos ) )
              {
                  pFound = pAction;
              }
          }
      }
      pAction = pAction->GetNext();
  }
  if ( !pFound )
      return;

  if ( pFoundContent && pFound->GetType() != SC_CAT_CONTENT )
      pFound = pFoundContent;     // Content wins
  if ( pFoundMove && pFound->GetType() != SC_CAT_MOVE &&
          pFoundMove->GetActionNumber() >
          pFound->GetActionNumber() )
      pFound = pFoundMove;        // Move wins
  //  for deleted columns: arrow on left side of row
  if ( pFound->GetType() == SC_CAT_DELETE_COLS )
      bLeftEdge = true;
  DateTime aDT = pFound->GetDateTime();
  aTrackText  = pFound->GetUser();
  aTrackText += ", ";
  aTrackText += ScGlobal::getLocaleDataPtr()->getDate(aDT);
  aTrackText += " ";
  aTrackText += ScGlobal::getLocaleDataPtr()->getTime(aDT);
  aTrackText += ":\n";
  OUString aComStr = pFound->GetComment();
  if(!aComStr.isEmpty())
  {
      aTrackText += aComStr;
      aTrackText += "\n( ";
  }
  pFound->GetDescription( aTrackText, *this );
  if (!aComStr.isEmpty())
  {
      aTrackText += ")";
  }
1350}

1352void ScDocument::SetPreviewFont( std::unique_ptr<SfxItemSet> pFont )
1353{
  pPreviewFont = std::move(pFont);
1355}

1357void  ScDocument::SetPreviewSelection( const ScMarkData& rSel )
1358{
  maPreviewSelection = rSel;
1360}

1362SfxItemSet* ScDocument::GetPreviewFont( SCCOL nCol, SCROW nRow, SCTAB nTab )
1363{
  SfxItemSet* pRet = nullptr;
  if ( pPreviewFont )
  {
      ScMarkData aSel = GetPreviewSelection();
      if ( aSel.IsCellMarked( nCol, nRow ) && aSel.GetFirstSelected() == nTab )
          pRet = pPreviewFont.get();
  }
  return pRet;
1372}

1374ScStyleSheet* ScDocument::GetPreviewCellStyle( SCCOL nCol, SCROW nRow, SCTAB nTab )
1375{
  ScStyleSheet* pRet = nullptr;
  ScMarkData aSel = GetPreviewSelection();
  if ( pPreviewCellStyle && aSel.IsCellMarked( nCol, nRow ) && aSel.GetFirstSelected() == nTab  )
      pRet = pPreviewCellStyle;
  return pRet;
1381}

1383sc::IconSetBitmapMap& ScDocument::GetIconSetBitmapMap()
1384{
  if (!m_pIconSetBitmapMap)
  {
      m_pIconSetBitmapMap.reset(new sc::IconSetBitmapMap);
  }
  return *m_pIconSetBitmapMap;
1390}

1392/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
  }

  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
    */
  reference_type * get() const
  {
      return m_rInnerRef.get();
  }

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
6
←
Calling copy constructor for 'Reference<VirtualDevice>'→
9
←
Returning from copy constructor for 'Reference<VirtualDevice>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
10
←
Calling 'Reference::clear'→
17
←
Returning; memory was released→
      if (aTmp.get()) {
18
←
Calling 'Reference::get'→
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

442/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
7
←
Assuming field 'm_pBody' is non-null→
8
←
Taking true branch→
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody10.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
11
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
12
←
Calling 'VclReferenceBase::release'→
16
←
Returning; memory was released→
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
19
←
Use of memory after it is freed
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 *   Licensed to the Apache Software Foundation (ASF) under one or more
12 *   contributor license agreements. See the NOTICE file distributed
13 *   with this work for additional information regarding copyright
14 *   ownership. The ASF licenses this file to you under the Apache
15 *   License, Version 2.0 (the "License"); you may not use this file
16 *   except in compliance with the License. You may obtain a copy of
17 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
13
←
Assuming the condition is true→
14
←
Taking true branch→
40            delete this;
15
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif