/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx
Warning:	line 2437, column 5 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 externalrefmgr.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/ui/docshell/externalrefmgr.cxx

/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.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 <externalrefmgr.hxx>
21#include <document.hxx>
22#include <token.hxx>
23#include <tokenarray.hxx>
24#include <address.hxx>
25#include <tablink.hxx>
26#include <docsh.hxx>
27#include <scextopt.hxx>
28#include <rangenam.hxx>
29#include <formulacell.hxx>
30#include <viewdata.hxx>
31#include <tabvwsh.hxx>
32#include <sc.hrc>
33#include <globstr.hrc>
34#include <scresid.hxx>
35#include <cellvalue.hxx>
36#include <defaultsoptions.hxx>
37#include <scmod.hxx>

39#include <o3tl/safeint.hxx>
40#include <osl/file.hxx>
41#include <sfx2/app.hxx>
42#include <sfx2/docfile.hxx>
43#include <sfx2/event.hxx>
44#include <sfx2/fcontnr.hxx>
45#include <sfx2/objsh.hxx>
46#include <svl/itemset.hxx>
47#include <svl/stritem.hxx>
48#include <svl/urihelper.hxx>
49#include <svl/sharedstringpool.hxx>
50#include <sfx2/linkmgr.hxx>
51#include <tools/urlobj.hxx>
52#include <unotools/charclass.hxx>
53#include <unotools/configmgr.hxx>
54#include <unotools/ucbhelper.hxx>
55#include <vcl/svapp.hxx>
56#include <vcl/weld.hxx>
57#include <stringutil.hxx>
58#include <scmatrix.hxx>
59#include <columnspanset.hxx>
60#include <column.hxx>
61#include <com/sun/star/document/MacroExecMode.hpp>
62#include <com/sun/star/document/UpdateDocMode.hpp>
63#include <sal/log.hxx>

65#include <memory>
66#include <algorithm>

68using ::std::unique_ptr;
69using ::com::sun::star::uno::Any;
70using ::std::vector;
71using ::std::find_if;
72using ::std::for_each;
73using ::std::distance;
74using ::std::pair;
75using namespace formula;

77#define SRCDOC_LIFE_SPAN30000     30000      // 5 minutes (in 100th of a sec)
78#define SRCDOC_SCAN_INTERVAL1000*30 1000*30    // every 30 seconds (in msec)

80namespace {

82class TabNameSearchPredicate
83{
84public:
  explicit TabNameSearchPredicate(const OUString& rSearchName) :
      maSearchName(ScGlobal::getCharClassPtr()->uppercase(rSearchName))
  {
  }

  bool operator()(const ScExternalRefCache::TableName& rTabNameSet) const
  {
      // Ok, I'm doing case insensitive search here.
      return rTabNameSet.maUpperName == maSearchName;
  }

96private:
  OUString maSearchName;
98};

100class FindSrcFileByName
101{
102public:
  explicit FindSrcFileByName(const OUString& rMatchName) :
      mrMatchName(rMatchName)
  {
  }

  bool operator()(const ScExternalRefManager::SrcFileData& rSrcData) const
  {
      return rSrcData.maFileName == mrMatchName;
  }

113private:
  const OUString& mrMatchName;
115};

117class NotifyLinkListener
118{
119public:
  NotifyLinkListener(sal_uInt16 nFileId, ScExternalRefManager::LinkUpdateType eType) :
      mnFileId(nFileId), meType(eType) {}

  void operator() (ScExternalRefManager::LinkListener* p) const
  {
      p->notify(mnFileId, meType);
  }
127private:
  sal_uInt16 mnFileId;
  ScExternalRefManager::LinkUpdateType meType;
130};

132struct UpdateFormulaCell
133{
  void operator() (ScFormulaCell* pCell) const
  {
      // Check to make sure the cell really contains svExternal*.
      // External names, external cell and range references all have a
      // token of svExternal*. Additionally check for INDIRECT() that can be
      // called with any constructed URI string.
      ScTokenArray* pCode = pCell->GetCode();
      if (!pCode->HasExternalRef() && !pCode->HasOpCode(ocIndirect))
          return;

      if (pCode->GetCodeError() != FormulaError::NONE)
      {
          // Clear the error code, or a cell with error won't get re-compiled.
          pCode->SetCodeError(FormulaError::NONE);
          pCell->SetCompile(true);
          pCell->CompileTokenArray();
      }

      pCell->SetDirty();
  }
154};

156class RemoveFormulaCell
157{
158public:
  explicit RemoveFormulaCell(ScFormulaCell* p) : mpCell(p) {}
  void operator() (pair<const sal_uInt16, ScExternalRefManager::RefCellSet>& r) const
  {
      r.second.erase(mpCell);
  }
164private:
  ScFormulaCell* mpCell;
166};

168class ConvertFormulaToStatic
169{
170public:
  explicit ConvertFormulaToStatic(ScDocument* pDoc) : mpDoc(pDoc) {}
  void operator() (ScFormulaCell* pCell) const
  {
      ScAddress aPos = pCell->aPos;

      // We don't check for empty cells because empty external cells are
      // treated as having a value of 0.

      if (pCell->IsValue())
      {
          // Turn this into value cell.
          mpDoc->SetValue(aPos, pCell->GetValue());
      }
      else
      {
          // string cell otherwise.
          ScSetStringParam aParam;
          aParam.setTextInput();
          mpDoc->SetString(aPos, pCell->GetString().getString(), &aParam);
      }
  }
192private:
  ScDocument* mpDoc;
194};

196/**
* Check whether a named range contains an external reference to a
* particular document.
*/
200bool hasRefsToSrcDoc(ScRangeData& rData, sal_uInt16 nFileId)
201{
  ScTokenArray* pArray = rData.GetCode();
  if (!pArray)
      return false;

  formula::FormulaTokenArrayPlainIterator aIter(*pArray);
  formula::FormulaToken* p = aIter.GetNextReference();
  for (; p; p = aIter.GetNextReference())
  {
      if (!p->IsExternalRef())
          continue;

      if (p->GetIndex() == nFileId)
          return true;
  }
  return false;
217}

219class EraseRangeByIterator
220{
  ScRangeName& mrRanges;
222public:
  explicit EraseRangeByIterator(ScRangeName& rRanges) : mrRanges(rRanges) {}
  void operator() (const ScRangeName::iterator& itr)
  {
      mrRanges.erase(itr);
  }
228};

230/**
* Remove all named ranges that contain references to specified source
* document.
*/
234void removeRangeNamesBySrcDoc(ScRangeName& rRanges, sal_uInt16 nFileId)
235{
  ScRangeName::iterator itr = rRanges.begin(), itrEnd = rRanges.end();
  vector<ScRangeName::iterator> v;
  for (; itr != itrEnd; ++itr)
  {
      if (hasRefsToSrcDoc(*itr->second, nFileId))
          v.push_back(itr);
  }
  for_each(v.begin(), v.end(), EraseRangeByIterator(rRanges));
244}

246}

248ScExternalRefCache::Table::Table()
  : mbReferenced( true )
    // Prevent accidental data loss due to lack of knowledge.
251{
252}

254ScExternalRefCache::Table::~Table()
255{
256}

258void ScExternalRefCache::Table::clear()
259{
  maRows.clear();
  maCachedRanges.RemoveAll();
  mbReferenced = true;
263}

265void ScExternalRefCache::Table::setReferenced( bool bReferenced )
266{
  mbReferenced = bReferenced;
268}

270bool ScExternalRefCache::Table::isReferenced() const
271{
  return mbReferenced;
273}

275void ScExternalRefCache::Table::setCell(SCCOL nCol, SCROW nRow, TokenRef const & pToken, sal_uLong nFmtIndex, bool bSetCacheRange)
276{
  using ::std::pair;
  RowsDataType::iterator itrRow = maRows.find(nRow);
  if (itrRow == maRows.end())
  {
      // This row does not exist yet.
      pair<RowsDataType::iterator, bool> res = maRows.emplace(
          nRow, RowDataType());

      if (!res.second)
          return;

      itrRow = res.first;
  }

  // Insert this token into the specified column location.  I don't need to
  // check for existing data.  Just overwrite it.
  RowDataType& rRow = itrRow->second;
  ScExternalRefCache::Cell aCell;
  aCell.mxToken = pToken;
  aCell.mnFmtIndex = nFmtIndex;
  rRow.emplace(nCol, aCell);
  if (bSetCacheRange)
      setCachedCell(nCol, nRow);
300}

302ScExternalRefCache::TokenRef ScExternalRefCache::Table::getCell(SCCOL nCol, SCROW nRow, sal_uInt32* pnFmtIndex) const
303{
  RowsDataType::const_iterator itrTable = maRows.find(nRow);
  if (itrTable == maRows.end())
  {
      // this table doesn't have the specified row.
      return getEmptyOrNullToken(nCol, nRow);
  }

  const RowDataType& rRowData = itrTable->second;
  RowDataType::const_iterator itrRow = rRowData.find(nCol);
  if (itrRow == rRowData.end())
  {
      // this row doesn't have the specified column.
      return getEmptyOrNullToken(nCol, nRow);
  }

  const Cell& rCell = itrRow->second;
  if (pnFmtIndex)
      *pnFmtIndex = rCell.mnFmtIndex;

  return rCell.mxToken;
324}

326bool ScExternalRefCache::Table::hasRow( SCROW nRow ) const
327{
  RowsDataType::const_iterator itrRow = maRows.find(nRow);
  return itrRow != maRows.end();
330}

332void ScExternalRefCache::Table::getAllRows(vector<SCROW>& rRows, SCROW nLow, SCROW nHigh) const
333{
  vector<SCROW> aRows;
  aRows.reserve(maRows.size());
  for (const auto& rEntry : maRows)
      if (nLow <= rEntry.first && rEntry.first <= nHigh)
          aRows.push_back(rEntry.first);

  // hash map is not ordered, so we need to explicitly sort it.
  ::std::sort(aRows.begin(), aRows.end());
  rRows.swap(aRows);
343}

:std::pair< SCROW, SCROW > ScExternalRefCache::Table::getRowRange() const
346{
  ::std::pair< SCROW, SCROW > aRange( 0, 0 );
  if( !maRows.empty() )
  {
      // iterate over entire container (hash map is not sorted by key)
      auto itMinMax = std::minmax_element(maRows.begin(), maRows.end(),
          [](const RowsDataType::value_type& a, const RowsDataType::value_type& b) { return a.first < b.first; });
      aRange.first = itMinMax.first->first;
      aRange.second = itMinMax.second->first + 1;
  }
  return aRange;
357}

359void ScExternalRefCache::Table::getAllCols(SCROW nRow, vector<SCCOL>& rCols, SCCOL nLow, SCCOL nHigh) const
360{
  RowsDataType::const_iterator itrRow = maRows.find(nRow);
  if (itrRow == maRows.end())
      // this table doesn't have the specified row.
      return;

  const RowDataType& rRowData = itrRow->second;
  vector<SCCOL> aCols;
  aCols.reserve(rRowData.size());
  for (const auto& rCol : rRowData)
      if (nLow <= rCol.first && rCol.first <= nHigh)
          aCols.push_back(rCol.first);

  // hash map is not ordered, so we need to explicitly sort it.
  ::std::sort(aCols.begin(), aCols.end());
  rCols.swap(aCols);
376}

:std::pair< SCCOL, SCCOL > ScExternalRefCache::Table::getColRange( SCROW nRow ) const
379{
  ::std::pair< SCCOL, SCCOL > aRange( 0, 0 );

  RowsDataType::const_iterator itrRow = maRows.find( nRow );
  if (itrRow == maRows.end())
      // this table doesn't have the specified row.
      return aRange;

  const RowDataType& rRowData = itrRow->second;
  if( !rRowData.empty() )
  {
      // iterate over entire container (hash map is not sorted by key)
      auto itMinMax = std::minmax_element(rRowData.begin(), rRowData.end(),
          [](const RowDataType::value_type& a, const RowDataType::value_type& b) { return a.first < b.first; });
      aRange.first = itMinMax.first->first;
      aRange.second = itMinMax.second->first + 1;
  }
  return aRange;
397}

399void ScExternalRefCache::Table::getAllNumberFormats(vector<sal_uInt32>& rNumFmts) const
400{
  for (const auto& rRow : maRows)
  {
      const RowDataType& rRowData = rRow.second;
      for (const auto& rCol : rRowData)
      {
          const Cell& rCell = rCol.second;
          rNumFmts.push_back(rCell.mnFmtIndex);
      }
  }
410}

412bool ScExternalRefCache::Table::isRangeCached(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const
413{
  return maCachedRanges.In(ScRange(nCol1, nRow1, 0, nCol2, nRow2, 0));
415}

417void ScExternalRefCache::Table::setCachedCell(SCCOL nCol, SCROW nRow)
418{
  setCachedCellRange(nCol, nRow, nCol, nRow);
420}

422void ScExternalRefCache::Table::setCachedCellRange(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
423{
  ScRange aRange(nCol1, nRow1, 0, nCol2, nRow2, 0);
  maCachedRanges.Join(aRange);
426}

428void ScExternalRefCache::Table::setWholeTableCached()
429{
  setCachedCellRange(0, 0, MAXCOL, MAXROW);
431}

433bool ScExternalRefCache::Table::isInCachedRanges(SCCOL nCol, SCROW nRow) const
434{
  return maCachedRanges.In(ScRange(nCol, nRow, 0, nCol, nRow, 0));
436}

438ScExternalRefCache::TokenRef ScExternalRefCache::Table::getEmptyOrNullToken(
  SCCOL nCol, SCROW nRow) const
440{
  if (isInCachedRanges(nCol, nRow))
  {
      TokenRef p(new ScEmptyCellToken(false, false));
      return p;
  }
  return TokenRef();
447}

449ScExternalRefCache::TableName::TableName(const OUString& rUpper, const OUString& rReal) :
  maUpperName(rUpper), maRealName(rReal)
451{
452}

454ScExternalRefCache::CellFormat::CellFormat() :
  mbIsSet(false), mnType(SvNumFormatType::ALL), mnIndex(0)
456{
457}

459ScExternalRefCache::ScExternalRefCache()
: mxFakeDoc(new ScDocument())
461{}

463ScExternalRefCache::~ScExternalRefCache() {}

465const OUString* ScExternalRefCache::getRealTableName(sal_uInt16 nFileId, const OUString& rTabName) const
466{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocDataType::const_iterator itrDoc = maDocs.find(nFileId);
  if (itrDoc == maDocs.end())
  {
      // specified document is not cached.
      return nullptr;
  }

  const DocItem& rDoc = itrDoc->second;
  TableNameIndexMap::const_iterator itrTabId = rDoc.findTableNameIndex( rTabName);
  if (itrTabId == rDoc.maTableNameIndex.end())
  {
      // the specified table is not in cache.
      return nullptr;
  }

  return &rDoc.maTableNames[itrTabId->second].maRealName;
485}

487const OUString* ScExternalRefCache::getRealRangeName(sal_uInt16 nFileId, const OUString& rRangeName) const
488{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocDataType::const_iterator itrDoc = maDocs.find(nFileId);
  if (itrDoc == maDocs.end())
  {
      // specified document is not cached.
      return nullptr;
  }

  const DocItem& rDoc = itrDoc->second;
  NamePairMap::const_iterator itr = rDoc.maRealRangeNameMap.find(
      ScGlobal::getCharClassPtr()->uppercase(rRangeName));
  if (itr == rDoc.maRealRangeNameMap.end())
      // range name not found.
      return nullptr;

  return &itr->second;
506}

508ScExternalRefCache::TokenRef ScExternalRefCache::getCellData(
  sal_uInt16 nFileId, const OUString& rTabName, SCCOL nCol, SCROW nRow, sal_uInt32* pnFmtIndex)
510{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocDataType::const_iterator itrDoc = maDocs.find(nFileId);
  if (itrDoc == maDocs.end())
  {
      // specified document is not cached.
      return TokenRef();
  }

  const DocItem& rDoc = itrDoc->second;
  TableNameIndexMap::const_iterator itrTabId = rDoc.findTableNameIndex( rTabName);
  if (itrTabId == rDoc.maTableNameIndex.end())
  {
      // the specified table is not in cache.
      return TokenRef();
  }

  const TableTypeRef& pTableData = rDoc.maTables[itrTabId->second];
  if (!pTableData)
  {
      // the table data is not instantiated yet.
      return TokenRef();
  }

  return pTableData->getCell(nCol, nRow, pnFmtIndex);
536}

538ScExternalRefCache::TokenArrayRef ScExternalRefCache::getCellRangeData(
  sal_uInt16 nFileId, const OUString& rTabName, const ScRange& rRange)
540{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocDataType::iterator itrDoc = maDocs.find(nFileId);
  if (itrDoc == maDocs.end())
      // specified document is not cached.
      return TokenArrayRef();

  DocItem& rDoc = itrDoc->second;

  TableNameIndexMap::const_iterator itrTabId = rDoc.findTableNameIndex( rTabName);
  if (itrTabId == rDoc.maTableNameIndex.end())
      // the specified table is not in cache.
      return TokenArrayRef();

  const ScAddress& s = rRange.aStart;
  const ScAddress& e = rRange.aEnd;

  const SCTAB nTab1 = s.Tab(), nTab2 = e.Tab();
  const SCCOL nCol1 = s.Col(), nCol2 = e.Col();
  const SCROW nRow1 = s.Row(), nRow2 = e.Row();

  // Make sure I have all the tables cached.
  size_t nTabFirstId = itrTabId->second;
  size_t nTabLastId  = nTabFirstId + nTab2 - nTab1;
  if (nTabLastId >= rDoc.maTables.size())
      // not all tables are cached.
      return TokenArrayRef();

  ScRange aCacheRange( nCol1, nRow1, static_cast<SCTAB>(nTabFirstId), nCol2, nRow2, static_cast<SCTAB>(nTabLastId));

  RangeArrayMap::const_iterator itrRange = rDoc.maRangeArrays.find( aCacheRange);
  if (itrRange != rDoc.maRangeArrays.end())
      // Cache hit!
      return itrRange->second;

  std::unique_ptr<ScRange> pNewRange;
  TokenArrayRef pArray;
  bool bFirstTab = true;
  for (size_t nTab = nTabFirstId; nTab <= nTabLastId; ++nTab)
  {
      TableTypeRef pTab = rDoc.maTables[nTab];
      if (!pTab)
          return TokenArrayRef();

      SCCOL nDataCol1 = nCol1, nDataCol2 = nCol2;
      SCROW nDataRow1 = nRow1, nDataRow2 = nRow2;

      if (!pTab->isRangeCached(nDataCol1, nDataRow1, nDataCol2, nDataRow2))
      {
          // specified range is not entirely within cached ranges.
          return TokenArrayRef();
      }

      SCSIZE nMatrixColumns = static_cast<SCSIZE>(nDataCol2-nDataCol1+1);
      SCSIZE nMatrixRows = static_cast<SCSIZE>(nDataRow2-nDataRow1+1);
      ScMatrixRef xMat = new ScMatrix( nMatrixColumns, nMatrixRows);

      // Needed in shrink and fill.
      vector<SCROW> aRows;
      pTab->getAllRows(aRows, nDataRow1, nDataRow2);
      bool bFill = true;

      // Check if size could be allocated and if not skip the fill, there's
      // one error element instead. But retry first with the actual data area
      // if that is smaller than the original range, which works for most
      // functions just not some that operate/compare with the original size
      // and expect empty values in non-data areas.
      // Restrict this though to ranges of entire columns or rows, other
      // ranges might be on purpose. (Other special cases to handle?)
      /* TODO: sparse matrix could help */
      SCSIZE nMatCols, nMatRows;
      xMat->GetDimensions( nMatCols, nMatRows);
      if (nMatCols != nMatrixColumns || nMatRows != nMatrixRows)
      {
          bFill = false;
          if (aRows.empty())
          {
              // There's no data at all. Set the one matrix element to empty
              // for column-repeated and row-repeated access.
              xMat->PutEmpty(0,0);
          }
          else if ((nCol1 == 0 && nCol2 == MAXCOL) || (nRow1 == 0 && nRow2 == MAXROW))
          {
              nDataRow1 = aRows.front();
              nDataRow2 = aRows.back();
              SCCOL nMinCol = std::numeric_limits<SCCOL>::max();
              SCCOL nMaxCol = std::numeric_limits<SCCOL>::min();
              for (const auto& rRow : aRows)
              {
                  vector<SCCOL> aCols;
                  pTab->getAllCols(rRow, aCols, nDataCol1, nDataCol2);
                  if (!aCols.empty())
                  {
                      nMinCol = std::min( nMinCol, aCols.front());
                      nMaxCol = std::max( nMaxCol, aCols.back());
                  }
              }

              if (nMinCol <= nMaxCol && ((o3tl::make_unsigned(nMaxCol-nMinCol+1) < nMatrixColumns) ||
                          (o3tl::make_unsigned(nDataRow2-nDataRow1+1) < nMatrixRows)))
              {
                  nMatrixColumns = static_cast<SCSIZE>(nMaxCol-nMinCol+1);
                  nMatrixRows = static_cast<SCSIZE>(nDataRow2-nDataRow1+1);
                  xMat = new ScMatrix( nMatrixColumns, nMatrixRows);
                  xMat->GetDimensions( nMatCols, nMatRows);
                  if (nMatCols == nMatrixColumns && nMatRows == nMatrixRows)
                  {
                      nDataCol1 = nMinCol;
                      nDataCol2 = nMaxCol;
                      bFill = true;
                  }
              }
          }
      }

      if (bFill)
      {
          // Only fill non-empty cells, for better performance.
          for (SCROW nRow : aRows)
          {
              vector<SCCOL> aCols;
              pTab->getAllCols(nRow, aCols, nDataCol1, nDataCol2);
              for (SCCOL nCol : aCols)
              {
                  TokenRef pToken = pTab->getCell(nCol, nRow);
                  if (!pToken)
                      // This should never happen!
                      return TokenArrayRef();

                  SCSIZE nC = nCol - nDataCol1, nR = nRow - nDataRow1;
                  switch (pToken->GetType())
                  {
                      case svDouble:
                          xMat->PutDouble(pToken->GetDouble(), nC, nR);
                          break;
                      case svString:
                          xMat->PutString(pToken->GetString(), nC, nR);
                          break;
                      default:
                          ;
                  }
              }
          }

          if (!bFirstTab)
              pArray->AddOpCode(ocSep);

          ScMatrixToken aToken(xMat);
          if (!pArray)
              pArray = std::make_shared<ScTokenArray>(*mxFakeDoc);
          pArray->AddToken(aToken);

          bFirstTab = false;

          if (!pNewRange)
              pNewRange.reset(new ScRange(nDataCol1, nDataRow1, nTab, nDataCol2, nDataRow2, nTab));
          else
              pNewRange->ExtendTo(ScRange(nDataCol1, nDataRow1, nTab, nDataCol2, nDataRow2, nTab));
      }
  }

  rDoc.maRangeArrays.emplace(aCacheRange, pArray);
  if (pNewRange && *pNewRange != aCacheRange)
      rDoc.maRangeArrays.emplace(*pNewRange, pArray);

  return pArray;
707}

709ScExternalRefCache::TokenArrayRef ScExternalRefCache::getRangeNameTokens(sal_uInt16 nFileId, const OUString& rName)
710{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return TokenArrayRef();

  RangeNameMap& rMap = pDoc->maRangeNames;
  RangeNameMap::const_iterator itr = rMap.find(
      ScGlobal::getCharClassPtr()->uppercase(rName));
  if (itr == rMap.end())
      return TokenArrayRef();

  return itr->second;
724}

726void ScExternalRefCache::setRangeNameTokens(sal_uInt16 nFileId, const OUString& rName, TokenArrayRef pArray)
727{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return;

  OUString aUpperName = ScGlobal::getCharClassPtr()->uppercase(rName);
  RangeNameMap& rMap = pDoc->maRangeNames;
  rMap.emplace(aUpperName, pArray);
  pDoc->maRealRangeNameMap.emplace(aUpperName, rName);
738}

740bool ScExternalRefCache::isValidRangeName(sal_uInt16 nFileId, const OUString& rName) const
741{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return false;

  const RangeNameMap& rMap = pDoc->maRangeNames;
  return rMap.count(rName) > 0;
750}

752void ScExternalRefCache::setRangeName(sal_uInt16 nFileId, const OUString& rName)
753{
  osl::MutexGuard aGuard(&maMtxDocs);

  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return;

  OUString aUpperName = ScGlobal::getCharClassPtr()->uppercase(rName);
  pDoc->maRealRangeNameMap.emplace(aUpperName, rName);
762}

764void ScExternalRefCache::setCellData(sal_uInt16 nFileId, const OUString& rTabName, SCCOL nCol, SCROW nRow,
                                   TokenRef const & pToken, sal_uLong nFmtIndex)
766{
  if (!isDocInitialized(nFileId))
      return;

  using ::std::pair;
  DocItem* pDocItem = getDocItem(nFileId);
  if (!pDocItem)
      return;

  DocItem& rDoc = *pDocItem;

  // See if the table by this name already exists.
  TableNameIndexMap::const_iterator itrTabName = rDoc.findTableNameIndex( rTabName);
  if (itrTabName == rDoc.maTableNameIndex.end())
      // Table not found.  Maybe the table name or the file id is wrong ???
      return;

  TableTypeRef& pTableData = rDoc.maTables[itrTabName->second];
  if (!pTableData)
      pTableData = std::make_shared<Table>();

  pTableData->setCell(nCol, nRow, pToken, nFmtIndex);
  pTableData->setCachedCell(nCol, nRow);
789}

791void ScExternalRefCache::setCellRangeData(sal_uInt16 nFileId, const ScRange& rRange, const vector<SingleRangeData>& rData,
                                        const TokenArrayRef& pArray)
793{
  using ::std::pair;
  if (rData.empty() || !isDocInitialized(nFileId))
      // nothing to cache
      return;

  // First, get the document item for the given file ID.
  DocItem* pDocItem = getDocItem(nFileId);
  if (!pDocItem)
      return;

  DocItem& rDoc = *pDocItem;

  // Now, find the table position of the first table to cache.
  const OUString& rFirstTabName = rData.front().maTableName;
  TableNameIndexMap::const_iterator itrTabName = rDoc.findTableNameIndex( rFirstTabName);
  if (itrTabName == rDoc.maTableNameIndex.end())
  {
      // table index not found.
      return;
  }

  size_t nTabFirstId = itrTabName->second;
  SCROW nRow1 = rRange.aStart.Row(), nRow2 = rRange.aEnd.Row();
  SCCOL nCol1 = rRange.aStart.Col(), nCol2 = rRange.aEnd.Col();
  size_t i = nTabFirstId;
  for (const auto& rItem : rData)
  {
      TableTypeRef& pTabData = rDoc.maTables[i];
      if (!pTabData)
          pTabData = std::make_shared<Table>();

      const ScMatrixRef& pMat = rItem.mpRangeData;
      SCSIZE nMatCols, nMatRows;
      pMat->GetDimensions( nMatCols, nMatRows);
      if (nMatCols > o3tl::make_unsigned(nCol2 - nCol1) && nMatRows > o3tl::make_unsigned(nRow2 - nRow1))
      {
          ScMatrix::DoubleOpFunction aDoubleFunc = [=](size_t row, size_t col, double val) -> void
          {
              pTabData->setCell(col + nCol1, row + nRow1, new formula::FormulaDoubleToken(val), 0, false);
          };
          ScMatrix::BoolOpFunction aBoolFunc = [=](size_t row, size_t col, bool val) -> void
          {
              pTabData->setCell(col + nCol1, row + nRow1, new formula::FormulaDoubleToken(val ? 1.0 : 0.0), 0, false);
          };
          ScMatrix::StringOpFunction aStringFunc = [=](size_t row, size_t col, svl::SharedString val) -> void
          {
              pTabData->setCell(col + nCol1, row + nRow1, new formula::FormulaStringToken(val), 0, false);
          };
          ScMatrix::EmptyOpFunction aEmptyFunc = [=](size_t /*row*/, size_t /*col*/) -> void
          {
              // Nothing. Empty cell.
          };
          pMat->ExecuteOperation(std::pair<size_t, size_t>(0, 0),
                  std::pair<size_t, size_t>(nRow2-nRow1, nCol2-nCol1),
                  aDoubleFunc, aBoolFunc, aStringFunc, aEmptyFunc);
          // Mark the whole range 'cached'.
          pTabData->setCachedCellRange(nCol1, nRow1, nCol2, nRow2);
      }
      else
      {
          // This may happen due to a matrix not been allocated earlier, in
          // which case it should have exactly one error element.
          SAL_WARN("sc.ui","ScExternalRefCache::setCellRangeData - matrix size mismatch")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - matrix size mismatch"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "856" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - matrix size mismatch"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefCache::setCellRangeData - matrix size mismatch"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "856" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - matrix size mismatch"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "856" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - matrix size mismatch"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefCache::setCellRangeData - matrix size mismatch"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "856" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          if (nMatCols != 1 || nMatRows != 1)
              SAL_WARN("sc.ui","ScExternalRefCache::setCellRangeData - not a one element matrix")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - not a one element matrix"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "858" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - not a one element matrix"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefCache::setCellRangeData - not a one element matrix"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "858" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - not a one element matrix"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "858" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - not a one element matrix"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefCache::setCellRangeData - not a one element matrix"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "858" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          else
          {
              FormulaError nErr = GetDoubleErrorValue( pMat->GetDouble(0,0));
              SAL_WARN("sc.ui","ScExternalRefCache::setCellRangeData - matrix error value is " << static_cast<int>(nErr) <<do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok"); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok"); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false)
                      (nErr == FormulaError::MatrixSize ? ", ok" : ", not ok"))do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok"); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok")), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "ScExternalRefCache::setCellRangeData - matrix error value is "
 << static_cast<int>(nErr) << (nErr == FormulaError
::MatrixSize ? ", ok" : ", not ok"); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sc.ui"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "863" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          }
      }
      ++i;
  }

  size_t nTabLastId = nTabFirstId + rRange.aEnd.Tab() - rRange.aStart.Tab();
  ScRange aCacheRange( nCol1, nRow1, static_cast<SCTAB>(nTabFirstId), nCol2, nRow2, static_cast<SCTAB>(nTabLastId));

  rDoc.maRangeArrays.emplace(aCacheRange, pArray);
873}

875bool ScExternalRefCache::isDocInitialized(sal_uInt16 nFileId)
876{
  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return false;

  return pDoc->mbInitFromSource;
882}

884static bool lcl_getStrictTableDataIndex(const ScExternalRefCache::TableNameIndexMap& rMap, const OUString& rName, size_t& rIndex)
885{
  ScExternalRefCache::TableNameIndexMap::const_iterator itr = rMap.find(rName);
  if (itr == rMap.end())
      return false;

  rIndex = itr->second;
  return true;
892}

894bool ScExternalRefCache::DocItem::getTableDataIndex( const OUString& rTabName, size_t& rIndex ) const
895{
  ScExternalRefCache::TableNameIndexMap::const_iterator itr = findTableNameIndex(rTabName);
  if (itr == maTableNameIndex.end())
      return false;

  rIndex = itr->second;
  return true;
902}

904namespace {
905OUString getFirstSheetName()
906{
  // Get Custom prefix.
  const ScDefaultsOptions& rOpt = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetDefaultsOptions();
  // Form sheet name identical to the first generated sheet name when
  // creating an internal document, e.g. 'Sheet1'.
  return rOpt.GetInitTabPrefix() + "1";
912}
913}

915void ScExternalRefCache::initializeDoc(sal_uInt16 nFileId, const vector<OUString>& rTabNames,
      const OUString& rBaseName)
917{
  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return;

  size_t n = rTabNames.size();

  // table name list - the list must include all table names in the source
  // document and only to be populated when loading the source document, not
  // when loading cached data from, say, Excel XCT/CRN records.
  vector<TableName> aNewTabNames;
  aNewTabNames.reserve(n);
  for (const auto& rTabName : rTabNames)
  {
      TableName aNameItem(ScGlobal::getCharClassPtr()->uppercase(rTabName), rTabName);
      aNewTabNames.push_back(aNameItem);
  }
  pDoc->maTableNames.swap(aNewTabNames);

  // data tables - preserve any existing data that may have been set during
  // file import.
  vector<TableTypeRef> aNewTables(n);
  for (size_t i = 0; i < n; ++i)
  {
      size_t nIndex;
      if (lcl_getStrictTableDataIndex(pDoc->maTableNameIndex, pDoc->maTableNames[i].maUpperName, nIndex))
      {
          aNewTables[i] = pDoc->maTables[nIndex];
      }
  }
  pDoc->maTables.swap(aNewTables);

  // name index map
  TableNameIndexMap aNewNameIndex;
  for (size_t i = 0; i < n; ++i)
      aNewNameIndex.emplace(pDoc->maTableNames[i].maUpperName, i);
  pDoc->maTableNameIndex.swap(aNewNameIndex);

  // Setup name for Sheet1 vs base name to be able to load documents
  // that store the base name as table name, or vice versa.
  pDoc->maSingleTableNameAlias.clear();
  if (!rBaseName.isEmpty() && pDoc->maTableNames.size() == 1)
  {
      OUString aSheetName = getFirstSheetName();
      // If the one and only table name matches exactly, carry on the base
      // file name for further alias use. If instead the table name matches
      // the base name, carry on the sheet name as alias.
      if (ScGlobal::GetpTransliteration()->isEqual( pDoc->maTableNames[0].maRealName, aSheetName))
          pDoc->maSingleTableNameAlias = rBaseName;
      else if (ScGlobal::GetpTransliteration()->isEqual( pDoc->maTableNames[0].maRealName, rBaseName))
          pDoc->maSingleTableNameAlias = aSheetName;
  }

  pDoc->mbInitFromSource = true;
971}

973ScExternalRefCache::TableNameIndexMap::const_iterator ScExternalRefCache::DocItem::findTableNameIndex(
      const OUString& rTabName ) const
975{
  const OUString aTabNameUpper = ScGlobal::getCharClassPtr()->uppercase( rTabName);
  TableNameIndexMap::const_iterator itrTabName = maTableNameIndex.find( aTabNameUpper);
  if (itrTabName != maTableNameIndex.end())
      return itrTabName;

  // Since some time for external references to CSV files the base name is
  // used as sheet name instead of Sheet1, check if we can resolve that.
  // Also helps users that got accustomed to one or the other way.
  if (maSingleTableNameAlias.isEmpty() || maTableNameIndex.size() != 1)
      return itrTabName;

  // maSingleTableNameAlias has been set up only if the original file loaded
  // had exactly one sheet and internal sheet name was Sheet1 or localized or
  // customized equivalent, or base name.
  if (aTabNameUpper == ScGlobal::getCharClassPtr()->uppercase( maSingleTableNameAlias))
      return maTableNameIndex.begin();

  return itrTabName;
994}

996bool ScExternalRefCache::DocItem::getSingleTableNameAlternative( OUString& rTabName ) const
997{
  if (maSingleTableNameAlias.isEmpty() || maTableNames.size() != 1)
      return false;
  if (ScGlobal::GetpTransliteration()->isEqual( rTabName, maTableNames[0].maRealName))
  {
      rTabName = maSingleTableNameAlias;
      return true;
  }
  if (ScGlobal::GetpTransliteration()->isEqual( rTabName, maSingleTableNameAlias))
  {
      rTabName = maTableNames[0].maRealName;
      return true;
  }
  return false;
1011}

1013bool ScExternalRefCache::getSrcDocTable( const ScDocument& rSrcDoc, const OUString& rTabName, SCTAB& rTab,
      sal_uInt16 nFileId ) const
1015{
  bool bFound = rSrcDoc.GetTable( rTabName, rTab);
  if (!bFound)
  {
      // Check the one table alias alternative.
      const DocItem* pDoc = getDocItem( nFileId );
      if (pDoc)
      {
          OUString aTabName( rTabName);
          if (pDoc->getSingleTableNameAlternative( aTabName))
              bFound = rSrcDoc.GetTable( aTabName, rTab);
      }
  }
  return bFound;
1029}

1031OUString ScExternalRefCache::getTableName(sal_uInt16 nFileId, size_t nCacheId) const
1032{
  if( DocItem* pDoc = getDocItem( nFileId ) )
      if( nCacheId < pDoc->maTableNames.size() )
          return pDoc->maTableNames[ nCacheId ].maRealName;
  return EMPTY_OUSTRINGScGlobal::GetEmptyOUString();
1037}

1039void ScExternalRefCache::getAllTableNames(sal_uInt16 nFileId, vector<OUString>& rTabNames) const
1040{
  rTabNames.clear();
  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return;

  size_t n = pDoc->maTableNames.size();
  rTabNames.reserve(n);
  for (const auto& rTableName : pDoc->maTableNames)
      rTabNames.push_back(rTableName.maRealName);
1050}

1052SCTAB ScExternalRefCache::getTabSpan( sal_uInt16 nFileId, const OUString& rStartTabName, const OUString& rEndTabName ) const
1053{
  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
      return -1;

  vector<TableName>::const_iterator itrBeg = pDoc->maTableNames.begin();
  vector<TableName>::const_iterator itrEnd = pDoc->maTableNames.end();

  vector<TableName>::const_iterator itrStartTab = ::std::find_if( itrBeg, itrEnd,
          TabNameSearchPredicate( rStartTabName));
  if (itrStartTab == itrEnd)
      return -1;

  vector<TableName>::const_iterator itrEndTab = ::std::find_if( itrBeg, itrEnd,
          TabNameSearchPredicate( rEndTabName));
  if (itrEndTab == itrEnd)
      return 0;

  size_t nStartDist = ::std::distance( itrBeg, itrStartTab);
  size_t nEndDist = ::std::distance( itrBeg, itrEndTab);
  return nStartDist <= nEndDist ? static_cast<SCTAB>(nEndDist - nStartDist + 1) : -static_cast<SCTAB>(nStartDist - nEndDist + 1);
1074}

1076void ScExternalRefCache::getAllNumberFormats(vector<sal_uInt32>& rNumFmts) const
1077{
  osl::MutexGuard aGuard(&maMtxDocs);

  using ::std::sort;
  using ::std::unique;

  vector<sal_uInt32> aNumFmts;
  for (const auto& rEntry : maDocs)
  {
      const vector<TableTypeRef>& rTables = rEntry.second.maTables;
      for (const TableTypeRef& pTab : rTables)
      {
          if (!pTab)
              continue;

          pTab->getAllNumberFormats(aNumFmts);
      }
  }

  // remove duplicates.
  sort(aNumFmts.begin(), aNumFmts.end());
  aNumFmts.erase(unique(aNumFmts.begin(), aNumFmts.end()), aNumFmts.end());
  rNumFmts.swap(aNumFmts);
1100}

1102bool ScExternalRefCache::setCacheDocReferenced( sal_uInt16 nFileId )
1103{
  DocItem* pDocItem = getDocItem(nFileId);
  if (!pDocItem)
      return areAllCacheTablesReferenced();

  for (auto& rxTab : pDocItem->maTables)
  {
      if (rxTab)
          rxTab->setReferenced(true);
  }
  addCacheDocToReferenced( nFileId);
  return areAllCacheTablesReferenced();
1115}

1117bool ScExternalRefCache::setCacheTableReferenced( sal_uInt16 nFileId, const OUString& rTabName, size_t nSheets )
1118{
  DocItem* pDoc = getDocItem(nFileId);
  if (pDoc)
  {
      size_t nIndex = 0;
      if (pDoc->getTableDataIndex( rTabName, nIndex))
      {
          size_t nStop = ::std::min( nIndex + nSheets, pDoc->maTables.size());
          for (size_t i = nIndex; i < nStop; ++i)
          {
              TableTypeRef pTab = pDoc->maTables[i];
              if (pTab)
              {
                  if (!pTab->isReferenced())
                  {
                      pTab->setReferenced(true);
                      addCacheTableToReferenced( nFileId, i);
                  }
              }
          }
      }
  }
  return areAllCacheTablesReferenced();
1141}

1143void ScExternalRefCache::setAllCacheTableReferencedStati( bool bReferenced )
1144{
  osl::MutexGuard aGuard(&maMtxDocs);

  if (bReferenced)
  {
      maReferenced.reset(0);
      for (auto& rEntry : maDocs)
      {
          ScExternalRefCache::DocItem& rDocItem = rEntry.second;
          for (auto& rxTab : rDocItem.maTables)
          {
              if (rxTab)
                  rxTab->setReferenced(true);
          }
      }
  }
  else
  {
      size_t nDocs = 0;
      auto itrMax = std::max_element(maDocs.begin(), maDocs.end(),
          [](const DocDataType::value_type& a, const DocDataType::value_type& b) { return a.first < b.first; });
      if (itrMax != maDocs.end())
          nDocs = itrMax->first + 1;
      maReferenced.reset( nDocs);

      for (auto& [nFileId, rDocItem] : maDocs)
      {
          size_t nTables = rDocItem.maTables.size();
          ReferencedStatus::DocReferenced & rDocReferenced = maReferenced.maDocs[nFileId];
          // All referenced => non-existing tables evaluate as completed.
          rDocReferenced.maTables.resize( nTables, true);
          for (size_t i=0; i < nTables; ++i)
          {
              TableTypeRef & xTab = rDocItem.maTables[i];
              if (xTab)
              {
                  xTab->setReferenced(false);
                  rDocReferenced.maTables[i] = false;
                  rDocReferenced.mbAllTablesReferenced = false;
                  // An addCacheTableToReferenced() actually may have
                  // resulted in mbAllReferenced been set. Clear it.
                  maReferenced.mbAllReferenced = false;
              }
          }
      }
  }
1190}

1192void ScExternalRefCache::addCacheTableToReferenced( sal_uInt16 nFileId, size_t nIndex )
1193{
  if (nFileId >= maReferenced.maDocs.size())
      return;

  ::std::vector<bool> & rTables = maReferenced.maDocs[nFileId].maTables;
  size_t nTables = rTables.size();
  if (nIndex >= nTables)
      return;

  if (!rTables[nIndex])
  {
      rTables[nIndex] = true;
      size_t i = 0;
      while (i < nTables && rTables[i])
          ++i;
      if (i == nTables)
      {
          maReferenced.maDocs[nFileId].mbAllTablesReferenced = true;
          maReferenced.checkAllDocs();
      }
  }
1214}

1216void ScExternalRefCache::addCacheDocToReferenced( sal_uInt16 nFileId )
1217{
  if (nFileId >= maReferenced.maDocs.size())
      return;

  if (!maReferenced.maDocs[nFileId].mbAllTablesReferenced)
  {
      ::std::vector<bool> & rTables = maReferenced.maDocs[nFileId].maTables;
      size_t nSize = rTables.size();
      for (size_t i=0; i < nSize; ++i)
          rTables[i] = true;
      maReferenced.maDocs[nFileId].mbAllTablesReferenced = true;
      maReferenced.checkAllDocs();
  }
1230}

1232void ScExternalRefCache::getAllCachedDataSpans( const ScDocument& rSrcDoc, sal_uInt16 nFileId, sc::ColumnSpanSet& rSet ) const
1233{
  const DocItem* pDocItem = getDocItem(nFileId);
  if (!pDocItem)
      // This document is not cached.
      return;

  const std::vector<TableTypeRef>& rTables = pDocItem->maTables;
  for (size_t nTab = 0, nTabCount = rTables.size(); nTab < nTabCount; ++nTab)
  {
      TableTypeRef pTab = rTables[nTab];
      if (!pTab)
          continue;

      std::vector<SCROW> aRows;
      pTab->getAllRows(aRows);
      for (SCROW nRow : aRows)
      {
          std::vector<SCCOL> aCols;
          pTab->getAllCols(nRow, aCols);
          for (SCCOL nCol : aCols)
          {
              rSet.set(rSrcDoc, nTab, nCol, nRow, true);
          }
      }
  }
1258}

1260ScExternalRefCache::ReferencedStatus::ReferencedStatus() :
  mbAllReferenced(false)
1262{
  reset(0);
1264}

1266void ScExternalRefCache::ReferencedStatus::reset( size_t nDocs )
1267{
  if (nDocs)
  {
      mbAllReferenced = false;
      DocReferencedVec aRefs( nDocs);
      maDocs.swap( aRefs);
  }
  else
  {
      mbAllReferenced = true;
      DocReferencedVec aRefs;
      maDocs.swap( aRefs);
  }
1280}

1282void ScExternalRefCache::ReferencedStatus::checkAllDocs()
1283{
  if (std::all_of(maDocs.begin(), maDocs.end(), [](const DocReferenced& rDoc) { return rDoc.mbAllTablesReferenced; }))
      mbAllReferenced = true;
1286}

1288ScExternalRefCache::TableTypeRef ScExternalRefCache::getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const
1289{
  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc || nTabIndex >= pDoc->maTables.size())
      return TableTypeRef();

  return pDoc->maTables[nTabIndex];
1295}

1297ScExternalRefCache::TableTypeRef ScExternalRefCache::getCacheTable(sal_uInt16 nFileId, const OUString& rTabName,
      bool bCreateNew, size_t* pnIndex, const OUString* pExtUrl)
1299{
  // In API, the index is transported as cached sheet ID of type sal_Int32 in
  // sheet::SingleReference.Sheet or sheet::ComplexReference.Reference1.Sheet
  // in a sheet::FormulaToken, choose a sensible value for N/A. Effectively
  // being 0xffffffff
  const size_t nNotAvailable = static_cast<size_t>( static_cast<sal_Int32>( -1));

  DocItem* pDoc = getDocItem(nFileId);
  if (!pDoc)
  {
      if (pnIndex) *pnIndex = nNotAvailable;
      return TableTypeRef();
  }

  DocItem& rDoc = *pDoc;

  size_t nIndex;
  if (rDoc.getTableDataIndex(rTabName, nIndex))
  {
      // specified table found.
      if( pnIndex ) *pnIndex = nIndex;
      if (bCreateNew && !rDoc.maTables[nIndex])
          rDoc.maTables[nIndex] = std::make_shared<Table>();

      return rDoc.maTables[nIndex];
  }

  if (!bCreateNew)
  {
      if (pnIndex) *pnIndex = nNotAvailable;
      return TableTypeRef();
  }

  // If this is the first table to be created propagate the base name or
  // Sheet1 as an alias. For subsequent tables remove it again.
  if (rDoc.maTableNames.empty())
  {
      if (pExtUrl)
      {
          const OUString aBaseName( INetURLObject( *pExtUrl).GetBase());
          const OUString aSheetName( getFirstSheetName());
          if (ScGlobal::GetpTransliteration()->isEqual( rTabName, aSheetName))
              pDoc->maSingleTableNameAlias = aBaseName;
          else if (ScGlobal::GetpTransliteration()->isEqual( rTabName, aBaseName))
              pDoc->maSingleTableNameAlias = aSheetName;
      }
  }
  else
  {
      rDoc.maSingleTableNameAlias.clear();
  }

  // Specified table doesn't exist yet.  Create one.
  OUString aTabNameUpper = ScGlobal::getCharClassPtr()->uppercase(rTabName);
  nIndex = rDoc.maTables.size();
  if( pnIndex ) *pnIndex = nIndex;
  TableTypeRef pTab = std::make_shared<Table>();
  rDoc.maTables.push_back(pTab);
  rDoc.maTableNames.emplace_back(aTabNameUpper, rTabName);
  rDoc.maTableNameIndex.emplace(aTabNameUpper, nIndex);
  return pTab;
1360}

1362void ScExternalRefCache::clearCache(sal_uInt16 nFileId)
1363{
  osl::MutexGuard aGuard(&maMtxDocs);
  maDocs.erase(nFileId);
1366}

1368void ScExternalRefCache::clearCacheTables(sal_uInt16 nFileId)
1369{
  osl::MutexGuard aGuard(&maMtxDocs);
  DocItem* pDocItem = getDocItem(nFileId);
  if (!pDocItem)
      // This document is not cached at all.
      return;

  // Clear all cache table content, but keep the tables.
  std::vector<TableTypeRef>& rTabs = pDocItem->maTables;
  for (TableTypeRef & pTab : rTabs)
  {
      if (!pTab)
          continue;

      pTab->clear();
  }

  // Clear the external range name caches.
  pDocItem->maRangeNames.clear();
  pDocItem->maRangeArrays.clear();
  pDocItem->maRealRangeNameMap.clear();
1390}

1392ScExternalRefCache::DocItem* ScExternalRefCache::getDocItem(sal_uInt16 nFileId) const
1393{
  osl::MutexGuard aGuard(&maMtxDocs);

  using ::std::pair;
  DocDataType::iterator itrDoc = maDocs.find(nFileId);
  if (itrDoc == maDocs.end())
  {
      // specified document is not cached.
      pair<DocDataType::iterator, bool> res = maDocs.emplace(
              nFileId, DocItem());

      if (!res.second)
          // insertion failed.
          return nullptr;

      itrDoc = res.first;
  }

  return &itrDoc->second;
1412}

1414ScExternalRefLink::ScExternalRefLink(ScDocument& rDoc, sal_uInt16 nFileId) :
  ::sfx2::SvBaseLink(::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SIMPLE_FILE),
  mnFileId(nFileId),
  mrDoc(rDoc),
  mbDoRefresh(true)
1419{
1420}

1422ScExternalRefLink::~ScExternalRefLink()
1423{
1424}

1426void ScExternalRefLink::Closed()
1427{
  ScExternalRefManager* pMgr = mrDoc.GetExternalRefManager();
  pMgr->breakLink(mnFileId);
1430}

:sfx2::SvBaseLink::UpdateResult ScExternalRefLink::DataChanged(const OUString& /*rMimeType*/, const Any& /*rValue*/)
1433{
  if (!mbDoRefresh)
      return SUCCESS;

  OUString aFile, aFilter;
  sfx2::LinkManager::GetDisplayNames(this, nullptr, &aFile, nullptr, &aFilter);
  ScExternalRefManager* pMgr = mrDoc.GetExternalRefManager();

  if (!pMgr->isFileLoadable(aFile))
      return ERROR_GENERAL;

  const OUString* pCurFile = pMgr->getExternalFileName(mnFileId);
  if (!pCurFile)
      return ERROR_GENERAL;

  if (*pCurFile == aFile)
  {
      // Refresh the current source document.
      if (!pMgr->refreshSrcDocument(mnFileId))
          return ERROR_GENERAL;
  }
  else
  {
      // The source document has changed.
      ScDocShell* pDocShell = ScDocShell::GetViewData()->GetDocShell();
      ScDocShellModificator aMod(*pDocShell);
      pMgr->switchSrcFile(mnFileId, aFile, aFilter);
      aMod.SetDocumentModified();
  }

  return SUCCESS;
1464}

1466void ScExternalRefLink::Edit(weld::Window* pParent, const Link<SvBaseLink&,void>& /*rEndEditHdl*/)
1467{
  SvBaseLink::Edit(pParent, Link<SvBaseLink&,void>());
1469}

1471void ScExternalRefLink::SetDoRefresh(bool b)
1472{
  mbDoRefresh = b;
1474}

1476static FormulaToken* convertToToken( ScDocument& rHostDoc, const ScDocument& rSrcDoc, ScRefCellValue& rCell )
1477{
  if (rCell.hasEmptyValue())
  {
      bool bInherited = (rCell.meType == CELLTYPE_FORMULA);
      return new ScEmptyCellToken(bInherited, false);
  }

  switch (rCell.meType)
  {
      case CELLTYPE_EDIT:
      case CELLTYPE_STRING:
      {
          OUString aStr = rCell.getString(&rSrcDoc);
          svl::SharedString aSS = rHostDoc.GetSharedStringPool().intern(aStr);
          return new formula::FormulaStringToken(aSS);
      }
      case CELLTYPE_VALUE:
          return new formula::FormulaDoubleToken(rCell.mfValue);
      case CELLTYPE_FORMULA:
      {
          ScFormulaCell* pFCell = rCell.mpFormula;
          FormulaError nError = pFCell->GetErrCode();
          if (nError != FormulaError::NONE)
              return new FormulaErrorToken( nError);
          else if (pFCell->IsValue())
          {
              double fVal = pFCell->GetValue();
              return new formula::FormulaDoubleToken(fVal);
          }
          else
          {
              svl::SharedString aSS = rHostDoc.GetSharedStringPool().intern( pFCell->GetString().getString());
              return new formula::FormulaStringToken(aSS);
          }
      }
      default:
          OSL_FAIL("attempted to convert an unknown cell type.")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "1513" ": "), "%s", "attempted to convert an unknown cell type."
); } } while (false);
  }

  return nullptr;
1517}

1519static std::unique_ptr<ScTokenArray> convertToTokenArray(
  ScDocument& rHostDoc, const ScDocument& rSrcDoc, ScRange& rRange, vector<ScExternalRefCache::SingleRangeData>& rCacheData )
1521{
  ScAddress& s = rRange.aStart;
  ScAddress& e = rRange.aEnd;

  const SCTAB nTab1 = s.Tab(), nTab2 = e.Tab();
  const SCCOL nCol1 = s.Col(), nCol2 = e.Col();
  const SCROW nRow1 = s.Row(), nRow2 = e.Row();

  if (nTab2 != nTab1)
      // For now, we don't support multi-sheet ranges intentionally because
      // we don't have a way to express them in a single token.  In the
      // future we can introduce a new stack variable type svMatrixList with
      // a new token type that can store a 3D matrix value and convert a 3D
      // range to it.
      return nullptr;

  std::unique_ptr<ScRange> pUsedRange;

  unique_ptr<ScTokenArray> pArray(new ScTokenArray(rSrcDoc));
  bool bFirstTab = true;
  vector<ScExternalRefCache::SingleRangeData>::iterator
      itrCache = rCacheData.begin(), itrCacheEnd = rCacheData.end();

  for (SCTAB nTab = nTab1; nTab <= nTab2 && itrCache != itrCacheEnd; ++nTab, ++itrCache)
  {
      // Only loop within the data area.
      SCCOL nDataCol1 = nCol1, nDataCol2 = nCol2;
      SCROW nDataRow1 = nRow1, nDataRow2 = nRow2;
      bool bShrunk;
      if (!rSrcDoc.ShrinkToUsedDataArea( bShrunk, nTab, nDataCol1, nDataRow1, nDataCol2, nDataRow2, false))
          // no data within specified range.
          continue;

      if (pUsedRange)
          // Make sure the used area only grows, not shrinks.
          pUsedRange->ExtendTo(ScRange(nDataCol1, nDataRow1, 0, nDataCol2, nDataRow2, 0));
      else
          pUsedRange.reset(new ScRange(nDataCol1, nDataRow1, 0, nDataCol2, nDataRow2, 0));

      SCSIZE nMatrixColumns = static_cast<SCSIZE>(nCol2-nCol1+1);
      SCSIZE nMatrixRows = static_cast<SCSIZE>(nRow2-nRow1+1);
      ScMatrixRef xMat = new ScMatrix( nMatrixColumns, nMatrixRows);

      // Check if size could be allocated and if not skip the fill, there's
      // one error element instead. But retry first with the actual data area
      // if that is smaller than the original range, which works for most
      // functions just not some that operate/compare with the original size
      // and expect empty values in non-data areas.
      // Restrict this though to ranges of entire columns or rows, other
      // ranges might be on purpose. (Other special cases to handle?)
      /* TODO: sparse matrix could help */
      SCSIZE nMatCols, nMatRows;
      xMat->GetDimensions( nMatCols, nMatRows);
      if (nMatCols == nMatrixColumns && nMatRows == nMatrixRows)
      {
          rSrcDoc.FillMatrix(*xMat, nTab, nCol1, nRow1, nCol2, nRow2, &rHostDoc.GetSharedStringPool());
      }
      else if ((nCol1 == 0 && nCol2 == MAXCOL) || (nRow1 == 0 && nRow2 == MAXROW))
      {
          if ((o3tl::make_unsigned(nDataCol2-nDataCol1+1) < nMatrixColumns) ||
              (o3tl::make_unsigned(nDataRow2-nDataRow1+1) < nMatrixRows))
          {
              nMatrixColumns = static_cast<SCSIZE>(nDataCol2-nDataCol1+1);
              nMatrixRows = static_cast<SCSIZE>(nDataRow2-nDataRow1+1);
              xMat = new ScMatrix( nMatrixColumns, nMatrixRows);
              xMat->GetDimensions( nMatCols, nMatRows);
              if (nMatCols == nMatrixColumns && nMatRows == nMatrixRows)
                  rSrcDoc.FillMatrix(*xMat, nTab, nDataCol1, nDataRow1, nDataCol2, nDataRow2, &rHostDoc.GetSharedStringPool());
          }
      }

      if (!bFirstTab)
          pArray->AddOpCode(ocSep);

      ScMatrixToken aToken(xMat);
      pArray->AddToken(aToken);

      itrCache->mpRangeData = xMat;

      bFirstTab = false;
  }

  if (!pUsedRange)
      return nullptr;

  s.SetCol(pUsedRange->aStart.Col());
  s.SetRow(pUsedRange->aStart.Row());
  e.SetCol(pUsedRange->aEnd.Col());
  e.SetRow(pUsedRange->aEnd.Row());

  return pArray;
1612}

1614static std::unique_ptr<ScTokenArray> lcl_fillEmptyMatrix(const ScDocument& rDoc, const ScRange& rRange)
1615{
  SCSIZE nC = static_cast<SCSIZE>(rRange.aEnd.Col()-rRange.aStart.Col()+1);
  SCSIZE nR = static_cast<SCSIZE>(rRange.aEnd.Row()-rRange.aStart.Row()+1);
  ScMatrixRef xMat = new ScMatrix(nC, nR);

  ScMatrixToken aToken(xMat);
  unique_ptr<ScTokenArray> pArray(new ScTokenArray(rDoc));
  pArray->AddToken(aToken);
  return pArray;
1624}

1626namespace {
1627bool isLinkUpdateAllowedInDoc(const ScDocument& rDoc)
1628{
  SfxObjectShell* pDocShell = rDoc.GetDocumentShell();
  if (!pDocShell)
      return false;

  return pDocShell->GetEmbeddedObjectContainer().getUserAllowsLinkUpdate();
1634}
1635}

1637ScExternalRefManager::ScExternalRefManager(ScDocument& rDoc) :
  mrDoc(rDoc),
  mbInReferenceMarking(false),
  mbUserInteractionEnabled(true),
  mbDocTimerEnabled(true)
1642{
  maSrcDocTimer.SetInvokeHandler( LINK(this, ScExternalRefManager, TimeOutHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScExternalRefManager
 *>(this), &ScExternalRefManager::LinkStubTimeOutHdl) );
  maSrcDocTimer.SetTimeout(SRCDOC_SCAN_INTERVAL1000*30);
  maSrcDocTimer.SetDebugName( "sc::ScExternalRefManager maSrcDocTimer" );
1646}

1648ScExternalRefManager::~ScExternalRefManager()
1649{
  clear();
1651}

1653OUString ScExternalRefManager::getCacheTableName(sal_uInt16 nFileId, size_t nTabIndex) const
1654{
  return maRefCache.getTableName(nFileId, nTabIndex);
1656}

1658ScExternalRefCache::TableTypeRef ScExternalRefManager::getCacheTable(sal_uInt16 nFileId, size_t nTabIndex) const
1659{
  return maRefCache.getCacheTable(nFileId, nTabIndex);
1661}

1663ScExternalRefCache::TableTypeRef ScExternalRefManager::getCacheTable(
  sal_uInt16 nFileId, const OUString& rTabName, bool bCreateNew, size_t* pnIndex, const OUString* pExtUrl)
1665{
  return maRefCache.getCacheTable(nFileId, rTabName, bCreateNew, pnIndex, pExtUrl);
1667}

1669ScExternalRefManager::LinkListener::LinkListener()
1670{
1671}

1673ScExternalRefManager::LinkListener::~LinkListener()
1674{
1675}

1677ScExternalRefManager::ApiGuard::ApiGuard(const ScDocument& rDoc) :
  mpMgr(rDoc.GetExternalRefManager()),
  mbOldInteractionEnabled(mpMgr->mbUserInteractionEnabled)
1680{
  // We don't want user interaction handled in the API.
  mpMgr->mbUserInteractionEnabled = false;
1683}

1685ScExternalRefManager::ApiGuard::~ApiGuard()
1686{
  // Restore old value.
  mpMgr->mbUserInteractionEnabled = mbOldInteractionEnabled;
1689}

1691void ScExternalRefManager::getAllCachedTableNames(sal_uInt16 nFileId, vector<OUString>& rTabNames) const
1692{
  maRefCache.getAllTableNames(nFileId, rTabNames);
1694}

1696SCTAB ScExternalRefManager::getCachedTabSpan( sal_uInt16 nFileId, const OUString& rStartTabName, const OUString& rEndTabName ) const
1697{
  return maRefCache.getTabSpan( nFileId, rStartTabName, rEndTabName);
1699}

1701void ScExternalRefManager::getAllCachedNumberFormats(vector<sal_uInt32>& rNumFmts) const
1702{
  maRefCache.getAllNumberFormats(rNumFmts);
1704}

1706sal_uInt16 ScExternalRefManager::getExternalFileCount() const
1707{
  return static_cast< sal_uInt16 >( maSrcFiles.size() );
1709}

1711void ScExternalRefManager::markUsedByLinkListeners()
1712{
  bool bAllMarked = false;
  for (const auto& [rFileId, rLinkListeners] : maLinkListeners)
  {
      if (!rLinkListeners.empty())
          bAllMarked = maRefCache.setCacheDocReferenced(rFileId);

      if (bAllMarked)
          break;
      /* TODO: LinkListeners should remember the table they're listening to.
       * As is, listening to one table will mark all tables of the document
       * being referenced. */
  }
1725}

1727void ScExternalRefManager::markUsedExternalRefCells()
1728{
  for (const auto& rEntry : maRefCells)
  {
      for (ScFormulaCell* pCell : rEntry.second)
      {
          bool bUsed = pCell->MarkUsedExternalReferences();
          if (bUsed)
              // Return true when at least one cell references external docs.
              return;
      }
  }
1739}

1741bool ScExternalRefManager::setCacheTableReferenced( sal_uInt16 nFileId, const OUString& rTabName, size_t nSheets )
1742{
  return maRefCache.setCacheTableReferenced( nFileId, rTabName, nSheets);
1744}

1746void ScExternalRefManager::setAllCacheTableReferencedStati( bool bReferenced )
1747{
  mbInReferenceMarking = !bReferenced;
  maRefCache.setAllCacheTableReferencedStati( bReferenced );
1750}

1752void ScExternalRefManager::storeRangeNameTokens(sal_uInt16 nFileId, const OUString& rName, const ScTokenArray& rArray)
1753{
  ScExternalRefCache::TokenArrayRef pArray(rArray.Clone());
  maRefCache.setRangeNameTokens(nFileId, rName, pArray);
1756}

1758namespace {

1760/**
* Put a single cell data into internal cache table.
*
* @param pFmt optional cell format index that may need to be stored with
*             the cell value.
*/
1766void putCellDataIntoCache(
  ScExternalRefCache& rRefCache, const ScExternalRefCache::TokenRef& pToken,
  sal_uInt16 nFileId, const OUString& rTabName, const ScAddress& rCell,
  const ScExternalRefCache::CellFormat* pFmt)
1770{
  // Now, insert the token into cache table but don't cache empty cells.
  if (pToken->GetType() != formula::svEmptyCell)
  {
      sal_uLong nFmtIndex = (pFmt && pFmt->mbIsSet) ? pFmt->mnIndex : 0;
      rRefCache.setCellData(nFileId, rTabName, rCell.Col(), rCell.Row(), pToken, nFmtIndex);
  }
1777}

1779/**
* Put the data into our internal cache table.
*
* @param rRefCache cache table set.
* @param pArray single range data to be returned.
* @param nFileId external file ID
* @param rTabName name of the table where the data should be cached.
* @param rCacheData range data to be cached.
* @param rCacheRange original cache range, including the empty region if
*                    any.
* @param rDataRange reduced cache range that includes only the non-empty
*                   data area.
*/
1792void putRangeDataIntoCache(
  ScExternalRefCache& rRefCache, ScExternalRefCache::TokenArrayRef& pArray,
  sal_uInt16 nFileId, const OUString& rTabName,
  const vector<ScExternalRefCache::SingleRangeData>& rCacheData,
  const ScRange& rCacheRange, const ScRange& rDataRange)
1797{
  if (pArray)
      // Cache these values.
      rRefCache.setCellRangeData(nFileId, rDataRange, rCacheData, pArray);
  else
  {
      // Array is empty.  Fill it with an empty matrix of the required size.
      pArray = lcl_fillEmptyMatrix(*rRefCache.getFakeDoc(), rCacheRange);

      // Make sure to set this range 'cached', to prevent unnecessarily
      // accessing the src document time and time again.
      ScExternalRefCache::TableTypeRef pCacheTab =
          rRefCache.getCacheTable(nFileId, rTabName, true, nullptr, nullptr);
      if (pCacheTab)
          pCacheTab->setCachedCellRange(
              rCacheRange.aStart.Col(), rCacheRange.aStart.Row(), rCacheRange.aEnd.Col(), rCacheRange.aEnd.Row());
  }
1814}

1816/**
* When accessing an external document for the first time, we need to
* populate the cache with all its sheet names (whether they are referenced
* or not) in the correct order.  Many client codes that use external
* references make this assumption.
*
* @param rRefCache cache table set.
* @param pSrcDoc source document instance.
* @param nFileId external file ID associated with the source document.
*/
1826void initDocInCache(ScExternalRefCache& rRefCache, const ScDocument* pSrcDoc, sal_uInt16 nFileId)
1827{
  if (!pSrcDoc)
      return;

  if (rRefCache.isDocInitialized(nFileId))
      // Already initialized.  No need to do this twice.
      return;

  SCTAB nTabCount = pSrcDoc->GetTableCount();
  if (!nTabCount)
      return;

  // Populate the cache with all table names in the source document.
  vector<OUString> aTabNames;
  aTabNames.reserve(nTabCount);
  for (SCTAB i = 0; i < nTabCount; ++i)
  {
      OUString aName;
      pSrcDoc->GetName(i, aName);
      aTabNames.push_back(aName);
  }

  // Obtain the base name, don't bother if there are more than one sheets.
  OUString aBaseName;
  if (nTabCount == 1)
  {
      const SfxObjectShell* pShell = pSrcDoc->GetDocumentShell();
      if (pShell && pShell->GetMedium())
      {
          OUString aName = pShell->GetMedium()->GetName();
          aBaseName = INetURLObject( aName).GetBase();
      }
  }

  rRefCache.initializeDoc(nFileId, aTabNames, aBaseName);
1862}

1864}

1866bool ScExternalRefManager::getSrcDocTable( const ScDocument& rSrcDoc, const OUString& rTabName, SCTAB& rTab,
      sal_uInt16 nFileId ) const
1868{
  return maRefCache.getSrcDocTable( rSrcDoc, rTabName, rTab, nFileId);
1870}

1872ScExternalRefCache::TokenRef ScExternalRefManager::getSingleRefToken(
  sal_uInt16 nFileId, const OUString& rTabName, const ScAddress& rCell,
  const ScAddress* pCurPos, SCTAB* pTab, ScExternalRefCache::CellFormat* pFmt)
1875{
  if (pCurPos)
      insertRefCell(nFileId, *pCurPos);

  maybeLinkExternalFile(nFileId);

  if (pTab)
      *pTab = -1;

  if (pFmt)
      pFmt->mbIsSet = false;

  ScDocument* pSrcDoc = getInMemorySrcDocument(nFileId);
  if (pSrcDoc)
  {
      // source document already loaded in memory.  Re-use this instance.
      SCTAB nTab;
      if (!getSrcDocTable( *pSrcDoc, rTabName, nTab, nFileId))
      {
          // specified table name doesn't exist in the source document.
          ScExternalRefCache::TokenRef pToken(new FormulaErrorToken(FormulaError::NoRef));
          return pToken;
      }

      if (pTab)
          *pTab = nTab;

      ScExternalRefCache::TokenRef pToken =
          getSingleRefTokenFromSrcDoc(
              nFileId, *pSrcDoc, ScAddress(rCell.Col(),rCell.Row(),nTab), pFmt);

      putCellDataIntoCache(maRefCache, pToken, nFileId, rTabName, rCell, pFmt);
      return pToken;
  }

  // Check if the given table name and the cell position is cached.
  sal_uInt32 nFmtIndex = 0;
  ScExternalRefCache::TokenRef pToken = maRefCache.getCellData(
      nFileId, rTabName, rCell.Col(), rCell.Row(), &nFmtIndex);
  if (pToken)
  {
      // Cache hit !
      fillCellFormat(nFmtIndex, pFmt);
      return pToken;
  }

  // reference not cached.  read from the source document.
  pSrcDoc = getSrcDocument(nFileId);
  if (!pSrcDoc)
  {
      // Source document not reachable.
      if (!isLinkUpdateAllowedInDoc(mrDoc))
      {
          // Indicate with specific error.
          pToken.reset(new FormulaErrorToken(FormulaError::LinkFormulaNeedingCheck));
      }
      else
      {
          // Throw a reference error.
          pToken.reset(new FormulaErrorToken(FormulaError::NoRef));
      }
      return pToken;
  }

  SCTAB nTab;
  if (!getSrcDocTable( *pSrcDoc, rTabName, nTab, nFileId))
  {
      // specified table name doesn't exist in the source document.
      pToken.reset(new FormulaErrorToken(FormulaError::NoRef));
      return pToken;
  }

  if (pTab)
      *pTab = nTab;

  SCCOL nDataCol1 = 0, nDataCol2 = MAXCOL;
  SCROW nDataRow1 = 0, nDataRow2 = MAXROW;
  bool bData = pSrcDoc->ShrinkToDataArea(nTab, nDataCol1, nDataRow1, nDataCol2, nDataRow2);
  if (!bData || rCell.Col() < nDataCol1 || nDataCol2 < rCell.Col() || rCell.Row() < nDataRow1 || nDataRow2 < rCell.Row())
  {
      // requested cell is outside the data area.  Don't even bother caching
      // this data, but add it to the cached range to prevent accessing the
      // source document time and time again.
      ScExternalRefCache::TableTypeRef pCacheTab =
          maRefCache.getCacheTable(nFileId, rTabName, true, nullptr, nullptr);
      if (pCacheTab)
          pCacheTab->setCachedCell(rCell.Col(), rCell.Row());

      pToken.reset(new ScEmptyCellToken(false, false));
      return pToken;
  }

  pToken = getSingleRefTokenFromSrcDoc(
      nFileId, *pSrcDoc, ScAddress(rCell.Col(),rCell.Row(),nTab), pFmt);

  putCellDataIntoCache(maRefCache, pToken, nFileId, rTabName, rCell, pFmt);
  return pToken;
1972}

1974ScExternalRefCache::TokenArrayRef ScExternalRefManager::getDoubleRefTokens(
  sal_uInt16 nFileId, const OUString& rTabName, const ScRange& rRange, const ScAddress* pCurPos)
1976{
  if (pCurPos)
      insertRefCell(nFileId, *pCurPos);

  maybeLinkExternalFile(nFileId);

  ScRange aDataRange(rRange);
  ScDocument* pSrcDoc = getInMemorySrcDocument(nFileId);
  if (pSrcDoc)
  {
      // Document already loaded in memory.
      vector<ScExternalRefCache::SingleRangeData> aCacheData;
      ScExternalRefCache::TokenArrayRef pArray =
          getDoubleRefTokensFromSrcDoc(*pSrcDoc, rTabName, aDataRange, aCacheData);

      // Put the data into cache.
      putRangeDataIntoCache(maRefCache, pArray, nFileId, rTabName, aCacheData, rRange, aDataRange);
      return pArray;
  }

  // Check if the given table name and the cell position is cached.
  ScExternalRefCache::TokenArrayRef pArray =
      maRefCache.getCellRangeData(nFileId, rTabName, rRange);
  if (pArray)
      // Cache hit !
      return pArray;

  pSrcDoc = getSrcDocument(nFileId);
  if (!pSrcDoc)
  {
      // Source document is not reachable.  Throw a reference error.
      pArray = std::make_shared<ScTokenArray>(*maRefCache.getFakeDoc());
      pArray->AddToken(FormulaErrorToken(FormulaError::NoRef));
      return pArray;
  }

  vector<ScExternalRefCache::SingleRangeData> aCacheData;
  pArray = getDoubleRefTokensFromSrcDoc(*pSrcDoc, rTabName, aDataRange, aCacheData);

  // Put the data into cache.
  putRangeDataIntoCache(maRefCache, pArray, nFileId, rTabName, aCacheData, rRange, aDataRange);
  return pArray;
2018}

2020ScExternalRefCache::TokenArrayRef ScExternalRefManager::getRangeNameTokens(
  sal_uInt16 nFileId, const OUString& rName, const ScAddress* pCurPos)
2022{
  if (pCurPos)
      insertRefCell(nFileId, *pCurPos);

  maybeLinkExternalFile(nFileId);

  OUString aName = rName; // make a copy to have the casing corrected.
  ScDocument* pSrcDoc = getInMemorySrcDocument(nFileId);
  if (pSrcDoc)
  {
      // Document already loaded in memory.
      ScExternalRefCache::TokenArrayRef pArray =
          getRangeNameTokensFromSrcDoc(nFileId, *pSrcDoc, aName);

      if (pArray)
          // Cache this range name array.
          maRefCache.setRangeNameTokens(nFileId, aName, pArray);

      return pArray;
  }

  ScExternalRefCache::TokenArrayRef pArray = maRefCache.getRangeNameTokens(nFileId, rName);
  if (pArray)
      // This range name is cached.
      return pArray;

  pSrcDoc = getSrcDocument(nFileId);
  if (!pSrcDoc)
      // failed to load document from disk.
      return ScExternalRefCache::TokenArrayRef();

  pArray = getRangeNameTokensFromSrcDoc(nFileId, *pSrcDoc, aName);

  if (pArray)
      // Cache this range name array.
      maRefCache.setRangeNameTokens(nFileId, aName, pArray);

  return pArray;
2060}

2062namespace {

2064bool hasRangeName(const ScDocument& rDoc, const OUString& rName)
2065{
  ScRangeName* pExtNames = rDoc.GetRangeName();
  OUString aUpperName = ScGlobal::getCharClassPtr()->uppercase(rName);
  const ScRangeData* pRangeData = pExtNames->findByUpperName(aUpperName);
  return pRangeData != nullptr;
2070}

2072}

2074bool ScExternalRefManager::isValidRangeName(sal_uInt16 nFileId, const OUString& rName)
2075{
  maybeLinkExternalFile(nFileId);
  ScDocument* pSrcDoc = getInMemorySrcDocument(nFileId);
  if (pSrcDoc0.1
'pSrcDoc' is null
1
'pSrcDoc' is null
)
1
Taking false branch→
  {
      // Only check the presence of the name.
      if (hasRangeName(*pSrcDoc, rName))
      {
          maRefCache.setRangeName(nFileId, rName);
          return true;
      }
      return false;
  }

  if (maRefCache.isValidRangeName(nFileId, rName))
2
←
Taking false branch→
      // Range name is cached.
      return true;

  pSrcDoc = getSrcDocument(nFileId);
3
←
Calling 'ScExternalRefManager::getSrcDocument'→
  if (!pSrcDoc)
      // failed to load document from disk.
      return false;

  if (hasRangeName(*pSrcDoc, rName))
  {
      maRefCache.setRangeName(nFileId, rName);
      return true;
  }

  return false;
2105}

2107void ScExternalRefManager::refreshAllRefCells(sal_uInt16 nFileId)
2108{
  RefCellMap::iterator itrFile = maRefCells.find(nFileId);
  if (itrFile == maRefCells.end())
      return;

  RefCellSet& rRefCells = itrFile->second;
  for_each(rRefCells.begin(), rRefCells.end(), UpdateFormulaCell());

  ScViewData* pViewData = ScDocShell::GetViewData();
  if (!pViewData)
      return;

  ScTabViewShell* pVShell = pViewData->GetViewShell();
  if (!pVShell)
      return;

  // Repainting the grid also repaints the texts, but is there a better way
  // to refresh texts?
  pVShell->Invalidate(FID_REPAINT((26000 + 100) + 2));
  pVShell->PaintGrid();
2128}

2130namespace {

2132void insertRefCellByIterator(
  const ScExternalRefManager::RefCellMap::iterator& itr, ScFormulaCell* pCell)
2134{
  if (pCell)
  {
      itr->second.insert(pCell);
      pCell->SetIsExtRef();
  }
2140}

2142}

2144void ScExternalRefManager::insertRefCell(sal_uInt16 nFileId, const ScAddress& rCell)
2145{
  RefCellMap::iterator itr = maRefCells.find(nFileId);
  if (itr == maRefCells.end())
  {
      RefCellSet aRefCells;
      pair<RefCellMap::iterator, bool> r = maRefCells.emplace(
          nFileId, aRefCells);
      if (!r.second)
          // insertion failed.
          return;

      itr = r.first;
  }

  insertRefCellByIterator(itr, mrDoc.GetFormulaCell(rCell));
2160}

2162void ScExternalRefManager::insertRefCellFromTemplate( ScFormulaCell* pTemplateCell, ScFormulaCell* pCell )
2163{
  if (!pTemplateCell || !pCell)
      return;

  for (RefCellMap::iterator itr = maRefCells.begin(); itr != maRefCells.end(); ++itr)
  {
      if (itr->second.find(pTemplateCell) != itr->second.end())
          insertRefCellByIterator(itr, pCell);
  }
2172}

2174bool ScExternalRefManager::hasCellExternalReference(const ScAddress& rCell)
2175{
  ScFormulaCell* pCell = mrDoc.GetFormulaCell(rCell);

  if (pCell)
      return std::any_of(maRefCells.begin(), maRefCells.end(),
          [&pCell](const RefCellMap::value_type& rEntry) { return rEntry.second.find(pCell) != rEntry.second.end(); });

  return false;
2183}

2185void ScExternalRefManager::enableDocTimer( bool bEnable )
2186{
  if (mbDocTimerEnabled == bEnable)
      return;

  mbDocTimerEnabled = bEnable;
  if (mbDocTimerEnabled)
  {
      if (!maDocShells.empty())
      {
          for (auto& rEntry : maDocShells)
              rEntry.second.maLastAccess = tools::Time(tools::Time::SYSTEM);

          maSrcDocTimer.Start();
      }
  }
  else
      maSrcDocTimer.Stop();
2203}

2205void ScExternalRefManager::fillCellFormat(sal_uLong nFmtIndex, ScExternalRefCache::CellFormat* pFmt) const
2206{
  if (!pFmt)
      return;

  SvNumFormatType nFmtType = mrDoc.GetFormatTable()->GetType(nFmtIndex);
  if (nFmtType != SvNumFormatType::UNDEFINED)
  {
      pFmt->mbIsSet = true;
      pFmt->mnIndex = nFmtIndex;
      pFmt->mnType = nFmtType;
  }
2217}

2219ScExternalRefCache::TokenRef ScExternalRefManager::getSingleRefTokenFromSrcDoc(
  sal_uInt16 nFileId, ScDocument& rSrcDoc, const ScAddress& rPos,
  ScExternalRefCache::CellFormat* pFmt)
2222{
  // Get the cell from src doc, and convert it into a token.
  ScRefCellValue aCell(rSrcDoc, rPos);
  ScExternalRefCache::TokenRef pToken(convertToToken(mrDoc, rSrcDoc, aCell));

  if (!pToken)
  {
      // Generate an error for unresolvable cells.
      pToken.reset( new FormulaErrorToken( FormulaError::NoValue));
  }

  // Get number format information.
  sal_uInt32 nFmtIndex = 0;
  rSrcDoc.GetNumberFormat(rPos.Col(), rPos.Row(), rPos.Tab(), nFmtIndex);
  nFmtIndex = getMappedNumberFormat(nFileId, nFmtIndex, rSrcDoc);
  fillCellFormat(nFmtIndex, pFmt);
  return pToken;
2239}

2241ScExternalRefCache::TokenArrayRef ScExternalRefManager::getDoubleRefTokensFromSrcDoc(
  const ScDocument& rSrcDoc, const OUString& rTabName, ScRange& rRange,
  vector<ScExternalRefCache::SingleRangeData>& rCacheData)
2244{
  ScExternalRefCache::TokenArrayRef pArray;
  SCTAB nTab1;

  if (!rSrcDoc.GetTable(rTabName, nTab1))
  {
      // specified table name doesn't exist in the source document.
      pArray = std::make_shared<ScTokenArray>(rSrcDoc);
      pArray->AddToken(FormulaErrorToken(FormulaError::NoRef));
      return pArray;
  }

  ScRange aRange(rRange);
  aRange.PutInOrder();
  SCTAB nTabSpan = aRange.aEnd.Tab() - aRange.aStart.Tab();

  vector<ScExternalRefCache::SingleRangeData> aCacheData;
  aCacheData.reserve(nTabSpan+1);
  aCacheData.emplace_back();
  aCacheData.back().maTableName = ScGlobal::getCharClassPtr()->uppercase(rTabName);

  for (SCTAB i = 1; i < nTabSpan + 1; ++i)
  {
      OUString aTabName;
      if (!rSrcDoc.GetName(nTab1 + 1, aTabName))
          // source document doesn't have any table by the specified name.
          break;

      aCacheData.emplace_back();
      aCacheData.back().maTableName = ScGlobal::getCharClassPtr()->uppercase(aTabName);
  }

  aRange.aStart.SetTab(nTab1);
  aRange.aEnd.SetTab(nTab1 + nTabSpan);

  pArray = convertToTokenArray(mrDoc, rSrcDoc, aRange, aCacheData);
  rRange = aRange;
  rCacheData.swap(aCacheData);
  return pArray;
2283}

2285ScExternalRefCache::TokenArrayRef ScExternalRefManager::getRangeNameTokensFromSrcDoc(
  sal_uInt16 nFileId, const ScDocument& rSrcDoc, OUString& rName)
2287{
  ScRangeName* pExtNames = rSrcDoc.GetRangeName();
  OUString aUpperName = ScGlobal::getCharClassPtr()->uppercase(rName);
  const ScRangeData* pRangeData = pExtNames->findByUpperName(aUpperName);
  if (!pRangeData)
      return ScExternalRefCache::TokenArrayRef();

  // Parse all tokens in this external range data, and replace each absolute
  // reference token with an external reference token, and cache them.  Also
  // register the source document with the link manager if it's a new
  // source.

  ScExternalRefCache::TokenArrayRef pNew = std::make_shared<ScTokenArray>(rSrcDoc);

  ScTokenArray aCode(*pRangeData->GetCode());
  FormulaTokenArrayPlainIterator aIter(aCode);
  for (const FormulaToken* pToken = aIter.First(); pToken; pToken = aIter.Next())
  {
      bool bTokenAdded = false;
      switch (pToken->GetType())
      {
          case svSingleRef:
          {
              const ScSingleRefData& rRef = *pToken->GetSingleRef();
              OUString aTabName;
              rSrcDoc.GetName(rRef.Tab(), aTabName);
              ScExternalSingleRefToken aNewToken(nFileId, svl::SharedString( aTabName),   // string not interned
                      *pToken->GetSingleRef());
              pNew->AddToken(aNewToken);
              bTokenAdded = true;
          }
          break;
          case svDoubleRef:
          {
              const ScSingleRefData& rRef = *pToken->GetSingleRef();
              OUString aTabName;
              rSrcDoc.GetName(rRef.Tab(), aTabName);
              ScExternalDoubleRefToken aNewToken(nFileId, svl::SharedString( aTabName),   // string not interned
                      *pToken->GetDoubleRef());
              pNew->AddToken(aNewToken);
              bTokenAdded = true;
          }
          break;
          default:
              ;   // nothing
      }

      if (!bTokenAdded)
          pNew->AddToken(*pToken);
  }

  rName = pRangeData->GetName(); // Get the correctly-cased name.
  return pNew;
2340}

2342ScDocument* ScExternalRefManager::getInMemorySrcDocument(sal_uInt16 nFileId)
2343{
  const OUString* pFileName = getExternalFileName(nFileId);
  if (!pFileName)
      return nullptr;

  // Do not load document until it was allowed.
  if (!isLinkUpdateAllowedInDoc(mrDoc))
      return nullptr;

  ScDocument* pSrcDoc = nullptr;
  ScDocShell* pShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>, false));
  while (pShell)
  {
      SfxMedium* pMedium = pShell->GetMedium();
      if (pMedium && !pMedium->GetName().isEmpty())
      {
          // TODO: We should make the case sensitivity platform dependent.
          if (pFileName->equalsIgnoreAsciiCase(pMedium->GetName()))
          {
              // Found !
              pSrcDoc = &pShell->GetDocument();
              break;
          }
      }
      else
      {
          // handle unsaved documents here
          OUString aName = pShell->GetName();
          if (pFileName->equalsIgnoreAsciiCase(aName))
          {
              // Found !
              SrcShell aSrcDoc;
              aSrcDoc.maShell = pShell;
              maUnsavedDocShells.emplace(nFileId, aSrcDoc);
              StartListening(*pShell);
              pSrcDoc = &pShell->GetDocument();
              break;
          }
      }
      pShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pShell, checkSfxObjectShell<ScDocShell>, false));
  }

  initDocInCache(maRefCache, pSrcDoc, nFileId);
  return pSrcDoc;
2387}

2389ScDocument* ScExternalRefManager::getSrcDocument(sal_uInt16 nFileId)
2390{
  if (!mrDoc.IsExecuteLinkEnabled())
4
←
Assuming the condition is false→
5
←
Taking false branch→
      return nullptr;

  DocShellMap::iterator itrEnd = maDocShells.end();
  DocShellMap::iterator itr = maDocShells.find(nFileId);

  if (itr != itrEnd)
6
←
Taking false branch→
  {
      // document already loaded.

      SfxObjectShell* p = itr->second.maShell.get();
      itr->second.maLastAccess = tools::Time( tools::Time::SYSTEM );
      return &static_cast<ScDocShell*>(p)->GetDocument();
  }

  itrEnd = maUnsavedDocShells.end();
  itr = maUnsavedDocShells.find(nFileId);
  if (itr != itrEnd)
7
←
Taking false branch→
  {
      //document is unsaved document

      SfxObjectShell* p = itr->second.maShell.get();
      itr->second.maLastAccess = tools::Time( tools::Time::SYSTEM );
      return &static_cast<ScDocShell*>(p)->GetDocument();
  }

  const OUString* pFile = getExternalFileName(nFileId);
  if (!pFile7.1
'pFile' is non-null
1
'pFile' is non-null
)
8
←
Taking false branch→
      // no file name associated with this ID.
      return nullptr;

  SrcShell aSrcDoc;
  try
  {
      OUString aFilter;
      aSrcDoc.maShell = loadSrcDocument(nFileId, aFilter);
  }
  catch (const css::uno::Exception&)
  {
  }
  if (!aSrcDoc.maShell.is())
9
←
Taking false branch→
  {
      // source document could not be loaded.
      return nullptr;
  }

  return &cacheNewDocShell(nFileId, aSrcDoc);
10
←
Calling implicit destructor for 'SrcShell'→
11
←
Calling '~SvRef'→
21
←
Returning from '~SvRef'→
22
←
Returning from destructor for 'SrcShell'→
23
←
Use of memory after it is freed
2438}

2440SfxObjectShellRef ScExternalRefManager::loadSrcDocument(sal_uInt16 nFileId, OUString& rFilter)
2441{
  // Do not load document until it was allowed.
  if (!isLinkUpdateAllowedInDoc(mrDoc))
      return nullptr;

  const SrcFileData* pFileData = getExternalFileData(nFileId);
  if (!pFileData)
      return nullptr;

  // Always load the document by using the path created from the relative
  // path.  If the referenced document is not there, simply exit.  The
  // original file name should be used only when the relative path is not
  // given.
  OUString aFile = pFileData->maFileName;
  maybeCreateRealFileName(nFileId);
  if (!pFileData->maRealFileName.isEmpty())
      aFile = pFileData->maRealFileName;

  if (!isFileLoadable(aFile))
      return nullptr;

  OUString aOptions = pFileData->maFilterOptions;
  if ( !pFileData->maFilterName.isEmpty() )
      rFilter = pFileData->maFilterName;      // don't overwrite stored filter with guessed filter
  else
      ScDocumentLoader::GetFilterName(aFile, rFilter, aOptions, true, false);
  std::shared_ptr<const SfxFilter> pFilter = ScDocShell::Factory().GetFilterContainer()->GetFilter4FilterName(rFilter);

  if (pFileData->maRelativeName.isEmpty())
  {
      // Generate a relative file path.
      INetURLObject aBaseURL(getOwnDocumentName());
      aBaseURL.insertName("content.xml");

      OUString aStr = URIHelper::simpleNormalizedMakeRelative(
          aBaseURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), aFile);

      setRelativeFileName(nFileId, aStr);
  }

  std::unique_ptr<SfxItemSet> pSet(new SfxAllItemSet(SfxGetpApp()->GetPool()));
  if (!aOptions.isEmpty())
      pSet->Put(SfxStringItem(SID_FILE_FILTEROPTIONS(5000 + 527), aOptions));

  // make medium hidden to prevent assertion from progress bar
  pSet->Put( SfxBoolItem(SID_HIDDEN(5000 + 534), true) );

  // If the current document is allowed to execute macros then the referenced
  // document may execute macros according to the security configuration.
  // Similar for UpdateDocMode to update links, just that if we reach here
  // the user already allowed updates and intermediate documents are expected
  // to update as well. When loading the document ScDocShell::Load() will
  // check through ScDocShell::GetLinkUpdateModeState() if its location is
  // trusted.
  SfxObjectShell* pShell = mrDoc.GetDocumentShell();
  if (pShell)
  {
      SfxMedium* pMedium = pShell->GetMedium();
      if (pMedium)
      {
          const SfxPoolItem* pItem;
          if (pMedium->GetItemSet()->GetItemState( SID_MACROEXECMODE(5000 + 1319), false, &pItem ) == SfxItemState::SET &&
                  static_cast<const SfxUInt16Item*>(pItem)->GetValue() != css::document::MacroExecMode::NEVER_EXECUTE)
              pSet->Put( SfxUInt16Item( SID_MACROEXECMODE(5000 + 1319), css::document::MacroExecMode::USE_CONFIG));
      }

      pSet->Put( SfxUInt16Item( SID_UPDATEDOCMODE(5000 + 1668), css::document::UpdateDocMode::FULL_UPDATE));
  }

  unique_ptr<SfxMedium> pMedium(new SfxMedium(aFile, StreamMode::STD_READ, pFilter, std::move(pSet)));
  if (pMedium->GetError() != ERRCODE_NONEErrCode(0))
      return nullptr;

  // To load encrypted documents with password, user interaction needs to be enabled.
  pMedium->UseInteractionHandler(mbUserInteractionEnabled);

  ScDocShell* pNewShell = new ScDocShell(SfxModelFlags::EXTERNAL_LINK);
  SfxObjectShellRef aRef = pNewShell;

  // increment the recursive link count of the source document.
  ScExtDocOptions* pExtOpt = mrDoc.GetExtDocOptions();
  sal_uInt32 nLinkCount = pExtOpt ? pExtOpt->GetDocSettings().mnLinkCnt : 0;
  ScDocument& rSrcDoc = pNewShell->GetDocument();
  rSrcDoc.EnableExecuteLink(false); // to prevent circular access of external references.
  rSrcDoc.EnableUndo(false);
  rSrcDoc.LockAdjustHeight();
  rSrcDoc.EnableUserInteraction(false);

  ScExtDocOptions* pExtOptNew = rSrcDoc.GetExtDocOptions();
  if (!pExtOptNew)
  {
      rSrcDoc.SetExtDocOptions(std::make_unique<ScExtDocOptions>());
      pExtOptNew = rSrcDoc.GetExtDocOptions();
  }
  pExtOptNew->GetDocSettings().mnLinkCnt = nLinkCount + 1;

  if (!pNewShell->DoLoad(pMedium.release()))
  {
      aRef->DoClose();
      aRef.clear();
      return aRef;
  }

  // with UseInteractionHandler, options may be set by dialog during DoLoad
  OUString aNew = ScDocumentLoader::GetOptions(*pNewShell->GetMedium());
  if (!aNew.isEmpty() && aNew != aOptions)
      aOptions = aNew;
  setFilterData(nFileId, rFilter, aOptions);    // update the filter data, including the new options

  return aRef;
2551}

2553ScDocument& ScExternalRefManager::cacheNewDocShell( sal_uInt16 nFileId, SrcShell& rSrcShell )
2554{
  if (mbDocTimerEnabled && maDocShells.empty())
      // If this is the first source document insertion, start up the timer.
      maSrcDocTimer.Start();

  maDocShells.emplace(nFileId, rSrcShell);
  SfxObjectShell& rShell = *rSrcShell.maShell;
  ScDocument& rSrcDoc = static_cast<ScDocShell&>(rShell).GetDocument();
  initDocInCache(maRefCache, &rSrcDoc, nFileId);
  return rSrcDoc;
2564}

2566bool ScExternalRefManager::isFileLoadable(const OUString& rFile) const
2567{
  if (rFile.isEmpty())
      return false;

  if (isOwnDocument(rFile))
      return false;
  OUString aPhysical;
  if (osl::FileBase::getSystemPathFromFileURL(rFile, aPhysical)
      == osl::FileBase::E_None)
  {
      // #i114504# try IsFolder/Exists only for file URLs

      if (utl::UCBContentHelper::IsFolder(rFile))
          return false;

      return utl::UCBContentHelper::Exists(rFile);
  }
  else
      return true;    // for http and others, Exists doesn't work, but the URL can still be opened
2586}

2588void ScExternalRefManager::maybeLinkExternalFile( sal_uInt16 nFileId, bool bDeferFilterDetection )
2589{
  if (maLinkedDocs.count(nFileId))
      // file already linked, or the link has been broken.
      return;

  // Source document not linked yet.  Link it now.
  const OUString* pFileName = getExternalFileName(nFileId);
  if (!pFileName)
      return;

  OUString aFilter, aOptions;
  const SrcFileData* pFileData = getExternalFileData(nFileId);
  if (pFileData)
  {
      aFilter = pFileData->maFilterName;
      aOptions = pFileData->maFilterOptions;
  }

  // Filter detection may access external links; defer it until we are allowed.
  if (!bDeferFilterDetection)
      bDeferFilterDetection = !isLinkUpdateAllowedInDoc(mrDoc);

  // If a filter was already set (for example, loading the cached table),
  // don't call GetFilterName which has to access the source file.
  // If filter detection is deferred, the next successful loadSrcDocument()
  // will update SrcFileData filter name.
  if (aFilter.isEmpty() && !bDeferFilterDetection)
      ScDocumentLoader::GetFilterName(*pFileName, aFilter, aOptions, true, false);
  sfx2::LinkManager* pLinkMgr = mrDoc.GetLinkManager();
  if (!pLinkMgr)
  {
      SAL_WARN( "sc.ui", "ScExternalRefManager::maybeLinkExternalFile: pLinkMgr==NULL")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefManager::maybeLinkExternalFile: pLinkMgr==NULL"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2620" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScExternalRefManager::maybeLinkExternalFile: pLinkMgr==NULL"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefManager::maybeLinkExternalFile: pLinkMgr==NULL"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2620" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefManager::maybeLinkExternalFile: pLinkMgr==NULL"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2620" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScExternalRefManager::maybeLinkExternalFile: pLinkMgr==NULL"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefManager::maybeLinkExternalFile: pLinkMgr==NULL"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2620" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return;
  }
  ScExternalRefLink* pLink = new ScExternalRefLink(mrDoc, nFileId);
  OSL_ENSURE(pFileName, "ScExternalRefManager::maybeLinkExternalFile: file name pointer is NULL")do { if (true && (!(pFileName))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2624" ": "), "%s", "ScExternalRefManager::maybeLinkExternalFile: file name pointer is NULL"
); } } while (false);
  pLinkMgr->InsertFileLink(*pLink, sfx2::SvBaseLinkObjectType::ClientFile, *pFileName,
          (aFilter.isEmpty() && bDeferFilterDetection ? nullptr : &aFilter));

  pLink->SetDoRefresh(false);
  pLink->Update();
  pLink->SetDoRefresh(true);

  maLinkedDocs.emplace(nFileId, true);
2633}

2635void ScExternalRefManager::addFilesToLinkManager()
2636{
  if (maSrcFiles.empty())
      return;

  SAL_WARN_IF( maSrcFiles.size() >= SAL_MAX_UINT16,do { if (true && (maSrcFiles.size() >= ((sal_uInt16
) 0xFFFF))) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefManager::addFilesToLinkManager: files overflow"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefManager::addFilesToLinkManager: files overflow"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false)
          "sc.ui", "ScExternalRefManager::addFilesToLinkManager: files overflow")do { if (true && (maSrcFiles.size() >= ((sal_uInt16
) 0xFFFF))) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sc.ui")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case SAL_DETAIL_LOG_ACTION_LOG
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefManager::addFilesToLinkManager: files overflow"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "ScExternalRefManager::addFilesToLinkManager: files overflow"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ScExternalRefManager::addFilesToLinkManager: files overflow"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sc.ui"
), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "2641" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  const sal_uInt16 nSize = static_cast<sal_uInt16>( std::min<size_t>( maSrcFiles.size(), SAL_MAX_UINT16((sal_uInt16) 0xFFFF)));
  for (sal_uInt16 nFileId = 0; nFileId < nSize; ++nFileId)
      maybeLinkExternalFile( nFileId, true);
2645}

2647void ScExternalRefManager::SrcFileData::maybeCreateRealFileName(const OUString& rOwnDocName)
2648{
  if (maRelativeName.isEmpty())
      // No relative path given.  Nothing to do.
      return;

  if (!maRealFileName.isEmpty())
      // Real file name already created.  Nothing to do.
      return;

  // Formulate the absolute file path from the relative path.
  const OUString& rRelPath = maRelativeName;
  INetURLObject aBaseURL(rOwnDocName);
  aBaseURL.insertName("content.xml");
  bool bWasAbs = false;
  maRealFileName = aBaseURL.smartRel2Abs(rRelPath, bWasAbs).GetMainURL(INetURLObject::DecodeMechanism::NONE);
2663}

2665void ScExternalRefManager::maybeCreateRealFileName(sal_uInt16 nFileId)
2666{
  if (nFileId >= maSrcFiles.size())
      return;

  maSrcFiles[nFileId].maybeCreateRealFileName(getOwnDocumentName());
2671}

2673OUString ScExternalRefManager::getOwnDocumentName() const
2674{
  if (utl::ConfigManager::IsFuzzing())
      return "file:///tmp/document";

  SfxObjectShell* pShell = mrDoc.GetDocumentShell();
  if (!pShell)
      // This should not happen!
      return OUString();

  SfxMedium* pMed = pShell->GetMedium();
  if (!pMed)
      return OUString();

  return pMed->GetName();
2688}

2690bool ScExternalRefManager::isOwnDocument(const OUString& rFile) const
2691{
  return getOwnDocumentName() == rFile;
2693}

2695void ScExternalRefManager::convertToAbsName(OUString& rFile) const
2696{
  // unsaved documents have no AbsName
  ScDocShell* pShell = static_cast<ScDocShell*>(SfxObjectShell::GetFirst(checkSfxObjectShell<ScDocShell>, false));
  while (pShell)
  {
      if (rFile == pShell->GetName())
          return;

      pShell = static_cast<ScDocShell*>(SfxObjectShell::GetNext(*pShell, checkSfxObjectShell<ScDocShell>, false));
  }

  SfxObjectShell* pDocShell = mrDoc.GetDocumentShell();
  rFile = ScGlobal::GetAbsDocName(rFile, pDocShell);
2709}

2711sal_uInt16 ScExternalRefManager::getExternalFileId(const OUString& rFile)
2712{
  vector<SrcFileData>::const_iterator itrBeg = maSrcFiles.begin(), itrEnd = maSrcFiles.end();
  vector<SrcFileData>::const_iterator itr = find_if(itrBeg, itrEnd, FindSrcFileByName(rFile));
  if (itr != itrEnd)
  {
      size_t nId = distance(itrBeg, itr);
      return static_cast<sal_uInt16>(nId);
  }

  SrcFileData aData;
  aData.maFileName = rFile;
  maSrcFiles.push_back(aData);
  return static_cast<sal_uInt16>(maSrcFiles.size() - 1);
2725}

2727const OUString* ScExternalRefManager::getExternalFileName(sal_uInt16 nFileId, bool bForceOriginal)
2728{
  if (nFileId >= maSrcFiles.size())
      return nullptr;

  if (bForceOriginal)
      return &maSrcFiles[nFileId].maFileName;

  maybeCreateRealFileName(nFileId);

  if (!maSrcFiles[nFileId].maRealFileName.isEmpty())
      return &maSrcFiles[nFileId].maRealFileName;

  return &maSrcFiles[nFileId].maFileName;
2741}

2743std::vector<OUString> ScExternalRefManager::getAllCachedExternalFileNames() const
2744{
  std::vector<OUString> aNames;
  aNames.reserve(maSrcFiles.size());
  for (const SrcFileData& rData : maSrcFiles)
  {
      aNames.push_back(rData.maFileName);
  }

  return aNames;
2753}

2755bool ScExternalRefManager::hasExternalFile(sal_uInt16 nFileId) const
2756{
  return nFileId < maSrcFiles.size();
2758}

2760bool ScExternalRefManager::hasExternalFile(const OUString& rFile) const
2761{
  return ::std::any_of(maSrcFiles.begin(), maSrcFiles.end(), FindSrcFileByName(rFile));
2763}

2765const ScExternalRefManager::SrcFileData* ScExternalRefManager::getExternalFileData(sal_uInt16 nFileId) const
2766{
  if (nFileId >= maSrcFiles.size())
      return nullptr;

  return &maSrcFiles[nFileId];
2771}

2773const OUString* ScExternalRefManager::getRealTableName(sal_uInt16 nFileId, const OUString& rTabName) const
2774{
  return maRefCache.getRealTableName(nFileId, rTabName);
2776}

2778const OUString* ScExternalRefManager::getRealRangeName(sal_uInt16 nFileId, const OUString& rRangeName) const
2779{
  return maRefCache.getRealRangeName(nFileId, rRangeName);
2781}

2783template<typename MapContainer>
2784static void lcl_removeByFileId(sal_uInt16 nFileId, MapContainer& rMap)
2785{
  typename MapContainer::iterator itr = rMap.find(nFileId);
  if (itr != rMap.end())
  {
      // Close this document shell.
      itr->second.maShell->DoClose();
      rMap.erase(itr);
  }
2793}

2795void ScExternalRefManager::clearCache(sal_uInt16 nFileId)
2796{
  maRefCache.clearCache(nFileId);
2798}

2800namespace {

2802class RefCacheFiller : public sc::ColumnSpanSet::ColumnAction
2803{
  svl::SharedStringPool& mrStrPool;

  ScExternalRefCache& mrRefCache;
  ScExternalRefCache::TableTypeRef mpRefTab;
  sal_uInt16 mnFileId;
  ScColumn* mpCurCol;
  sc::ColumnBlockConstPosition maBlockPos;

2812public:
  RefCacheFiller( svl::SharedStringPool& rStrPool, ScExternalRefCache& rRefCache, sal_uInt16 nFileId ) :
      mrStrPool(rStrPool), mrRefCache(rRefCache), mnFileId(nFileId), mpCurCol(nullptr) {}

  virtual void startColumn( ScColumn* pCol ) override
  {
      mpCurCol = pCol;
      if (!mpCurCol)
          return;

      mpCurCol->InitBlockPosition(maBlockPos);
      mpRefTab = mrRefCache.getCacheTable(mnFileId, mpCurCol->GetTab());
  }

  virtual void execute( SCROW nRow1, SCROW nRow2, bool bVal ) override
  {
      if (!mpCurCol || !bVal)
          return;

      if (!mpRefTab)
          return;

      for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
      {
          ScExternalRefCache::TokenRef pTok;
          ScRefCellValue aCell = mpCurCol->GetCellValue(maBlockPos, nRow);
          switch (aCell.meType)
          {
              case CELLTYPE_STRING:
              case CELLTYPE_EDIT:
              {
                  OUString aStr = aCell.getString(&mpCurCol->GetDoc());
                  svl::SharedString aSS = mrStrPool.intern(aStr);
                  pTok.reset(new formula::FormulaStringToken(aSS));
              }
              break;
              case CELLTYPE_VALUE:
                  pTok.reset(new formula::FormulaDoubleToken(aCell.mfValue));
              break;
              case CELLTYPE_FORMULA:
              {
                  sc::FormulaResultValue aRes = aCell.mpFormula->GetResult();
                  switch (aRes.meType)
                  {
                      case sc::FormulaResultValue::Value:
                          pTok.reset(new formula::FormulaDoubleToken(aRes.mfValue));
                      break;
                      case sc::FormulaResultValue::String:
                      {
                          // Re-intern the string to the host document pool.
                          svl::SharedString aInterned = mrStrPool.intern(aRes.maString.getString());
                          pTok.reset(new formula::FormulaStringToken(aInterned));
                      }
                      break;
                      case sc::FormulaResultValue::Error:
                      case sc::FormulaResultValue::Invalid:
                      default:
                          pTok.reset(new FormulaErrorToken(FormulaError::NoValue));
                  }
              }
              break;
              default:
                  pTok.reset(new FormulaErrorToken(FormulaError::NoValue));
          }

          if (pTok)
          {
              // Cache this cell.
              mpRefTab->setCell(mpCurCol->GetCol(), nRow, pTok, mpCurCol->GetNumberFormat(mpCurCol->GetDoc().GetNonThreadedContext(), nRow));
              mpRefTab->setCachedCell(mpCurCol->GetCol(), nRow);
          }
      }
  };
2885};

2887}

2889bool ScExternalRefManager::refreshSrcDocument(sal_uInt16 nFileId)
2890{
  SfxObjectShellRef xDocShell;
  try
  {
      OUString aFilter;
      xDocShell = loadSrcDocument(nFileId, aFilter);
  }
  catch ( const css::uno::Exception& ) {}

  if (!xDocShell.is())
      // Failed to load the document.  Bail out.
      return false;

  ScDocShell& rDocSh = static_cast<ScDocShell&>(*xDocShell);
  ScDocument& rSrcDoc = rDocSh.GetDocument();

  sc::ColumnSpanSet aCachedArea;
  maRefCache.getAllCachedDataSpans(rSrcDoc, nFileId, aCachedArea);

  // Clear the existing cache, and refill it.  Make sure we keep the
  // existing cache table instances here.
  maRefCache.clearCacheTables(nFileId);
  RefCacheFiller aAction(mrDoc.GetSharedStringPool(), maRefCache, nFileId);
  aCachedArea.executeColumnAction(rSrcDoc, aAction);

  DocShellMap::iterator it = maDocShells.find(nFileId);
  if (it != maDocShells.end())
  {
      it->second.maShell->DoClose();
      it->second.maShell = xDocShell;
      it->second.maLastAccess = tools::Time(tools::Time::SYSTEM);
  }
  else
  {
      SrcShell aSrcDoc;
      aSrcDoc.maShell = xDocShell;
      aSrcDoc.maLastAccess = tools::Time(tools::Time::SYSTEM);
      cacheNewDocShell(nFileId, aSrcDoc);
  }

  // Update all cells containing names from this source document.
  refreshAllRefCells(nFileId);

  notifyAllLinkListeners(nFileId, LINK_MODIFIED);

  return true;
2936}

2938void ScExternalRefManager::breakLink(sal_uInt16 nFileId)
2939{
  // Turn all formula cells referencing this external document into static
  // cells.
  RefCellMap::iterator itrRefs = maRefCells.find(nFileId);
  if (itrRefs != maRefCells.end())
  {
      // Make a copy because removing the formula cells below will modify
      // the original container.
      RefCellSet aSet = itrRefs->second;
      for_each(aSet.begin(), aSet.end(), ConvertFormulaToStatic(&mrDoc));
      maRefCells.erase(nFileId);
  }

  // Remove all named ranges that reference this document.

  // Global named ranges.
  ScRangeName* pRanges = mrDoc.GetRangeName();
  if (pRanges)
      removeRangeNamesBySrcDoc(*pRanges, nFileId);

  // Sheet-local named ranges.
  for (SCTAB i = 0, n = mrDoc.GetTableCount(); i < n; ++i)
  {
      pRanges = mrDoc.GetRangeName(i);
      if (pRanges)
          removeRangeNamesBySrcDoc(*pRanges, nFileId);
  }

  clearCache(nFileId);
  lcl_removeByFileId(nFileId, maDocShells);

  if (maDocShells.empty())
      maSrcDocTimer.Stop();

  LinkedDocMap::iterator itr = maLinkedDocs.find(nFileId);
  if (itr != maLinkedDocs.end())
      itr->second = false;

  notifyAllLinkListeners(nFileId, LINK_BROKEN);
2978}

2980void ScExternalRefManager::switchSrcFile(sal_uInt16 nFileId, const OUString& rNewFile, const OUString& rNewFilter)
2981{
  maSrcFiles[nFileId].maFileName = rNewFile;
  maSrcFiles[nFileId].maRelativeName.clear();
  maSrcFiles[nFileId].maRealFileName.clear();
  if (maSrcFiles[nFileId].maFilterName != rNewFilter)
  {
      // Filter type has changed.
      maSrcFiles[nFileId].maFilterName = rNewFilter;
      maSrcFiles[nFileId].maFilterOptions.clear();
  }
  refreshSrcDocument(nFileId);
2992}

2994void ScExternalRefManager::setRelativeFileName(sal_uInt16 nFileId, const OUString& rRelUrl)
2995{
  if (nFileId >= maSrcFiles.size())
      return;
  maSrcFiles[nFileId].maRelativeName = rRelUrl;
2999}

3001void ScExternalRefManager::setFilterData(sal_uInt16 nFileId, const OUString& rFilterName, const OUString& rOptions)
3002{
  if (nFileId >= maSrcFiles.size())
      return;
  maSrcFiles[nFileId].maFilterName = rFilterName;
  maSrcFiles[nFileId].maFilterOptions = rOptions;
3007}

3009void ScExternalRefManager::clear()
3010{
  for (auto& rEntry : maDocShells)
      rEntry.second.maShell->DoClose();

  maDocShells.clear();
  maSrcDocTimer.Stop();
3016}

3018bool ScExternalRefManager::hasExternalData() const
3019{
  return !maSrcFiles.empty();
3021}

3023void ScExternalRefManager::resetSrcFileData(const OUString& rBaseFileUrl)
3024{
  for (auto& rSrcFile : maSrcFiles)
  {
      // Re-generate relative file name from the absolute file name.
      OUString aAbsName = rSrcFile.maRealFileName;
      if (aAbsName.isEmpty())
          aAbsName = rSrcFile.maFileName;

      rSrcFile.maRelativeName = URIHelper::simpleNormalizedMakeRelative(
          rBaseFileUrl, aAbsName);
  }
3035}

3037void ScExternalRefManager::updateAbsAfterLoad()
3038{
  OUString aOwn( getOwnDocumentName() );
  for (auto& rSrcFile : maSrcFiles)
  {
      // update maFileName to the real file name,
      // to be called when the original name is no longer needed (after CompileXML)

      rSrcFile.maybeCreateRealFileName( aOwn );
      OUString aReal = rSrcFile.maRealFileName;
      if (!aReal.isEmpty())
          rSrcFile.maFileName = aReal;
  }
3050}

3052void ScExternalRefManager::removeRefCell(ScFormulaCell* pCell)
3053{
  for_each(maRefCells.begin(), maRefCells.end(), RemoveFormulaCell(pCell));
3055}

3057void ScExternalRefManager::addLinkListener(sal_uInt16 nFileId, LinkListener* pListener)
3058{
  LinkListenerMap::iterator itr = maLinkListeners.find(nFileId);
  if (itr == maLinkListeners.end())
  {
      pair<LinkListenerMap::iterator, bool> r = maLinkListeners.emplace(
          nFileId, LinkListeners());
      if (!r.second)
      {
          OSL_FAIL("insertion of new link listener list failed")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/docshell/externalrefmgr.cxx"
 ":" "3066" ": "), "%s", "insertion of new link listener list failed"
); } } while (false);
          return;
      }

      itr = r.first;
  }

  LinkListeners& rList = itr->second;
  rList.insert(pListener);
3075}

3077void ScExternalRefManager::removeLinkListener(sal_uInt16 nFileId, LinkListener* pListener)
3078{
  LinkListenerMap::iterator itr = maLinkListeners.find(nFileId);
  if (itr == maLinkListeners.end())
      // no listeners for a specified file.
      return;

  LinkListeners& rList = itr->second;
  rList.erase(pListener);

  if (rList.empty())
      // No more listeners for this file.  Remove its entry.
      maLinkListeners.erase(itr);
3090}

3092void ScExternalRefManager::removeLinkListener(LinkListener* pListener)
3093{
  for (auto& rEntry : maLinkListeners)
      rEntry.second.erase(pListener);
3096}

3098void ScExternalRefManager::notifyAllLinkListeners(sal_uInt16 nFileId, LinkUpdateType eType)
3099{
  LinkListenerMap::iterator itr = maLinkListeners.find(nFileId);
  if (itr == maLinkListeners.end())
      // no listeners for a specified file.
      return;

  LinkListeners& rList = itr->second;
  for_each(rList.begin(), rList.end(), NotifyLinkListener(nFileId, eType));
3107}

3109void ScExternalRefManager::purgeStaleSrcDocument(sal_Int32 nTimeOut)
3110{
  // To avoid potentially freezing Calc, we close one stale document at a time.
  DocShellMap::iterator itr = std::find_if(maDocShells.begin(), maDocShells.end(),
      [nTimeOut](const DocShellMap::value_type& rEntry) {
          // in 100th of a second.
          sal_Int32 nSinceLastAccess = (tools::Time( tools::Time::SYSTEM ) - rEntry.second.maLastAccess).GetTime();
          return nSinceLastAccess >= nTimeOut;
      });
  if (itr != maDocShells.end())
  {
      // Timed out.  Let's close this.
      itr->second.maShell->DoClose();
      maDocShells.erase(itr);
  }

  if (maDocShells.empty())
      maSrcDocTimer.Stop();
3127}

3129sal_uInt32 ScExternalRefManager::getMappedNumberFormat(sal_uInt16 nFileId, sal_uInt32 nNumFmt, const ScDocument& rSrcDoc)
3130{
  NumFmtMap::iterator itr = maNumFormatMap.find(nFileId);
  if (itr == maNumFormatMap.end())
  {
      // Number formatter map is not initialized for this external document.
      pair<NumFmtMap::iterator, bool> r = maNumFormatMap.emplace(
          nFileId, SvNumberFormatterMergeMap());

      if (!r.second)
          // insertion failed.
          return nNumFmt;

      itr = r.first;
      mrDoc.GetFormatTable()->MergeFormatter(*rSrcDoc.GetFormatTable());
      SvNumberFormatterMergeMap aMap = mrDoc.GetFormatTable()->ConvertMergeTableToMap();
      itr->second.swap(aMap);
  }
  const SvNumberFormatterMergeMap& rMap = itr->second;
  SvNumberFormatterMergeMap::const_iterator itrNumFmt = rMap.find(nNumFmt);
  if (itrNumFmt != rMap.end())
      // mapped value found.
      return itrNumFmt->second;

  return nNumFmt;
3154}

3156void ScExternalRefManager::transformUnsavedRefToSavedRef( SfxObjectShell* pShell )
3157{
  DocShellMap::iterator itr = maUnsavedDocShells.begin();
  while( itr != maUnsavedDocShells.end() )
  {
      if ( itr->second.maShell.get() == pShell )
      {
          // found that the shell is marked as unsaved
          OUString aFileURL = pShell->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::ToIUri);
          switchSrcFile(itr->first, aFileURL, OUString());
          EndListening(*pShell);
          maUnsavedDocShells.erase(itr++);
      }
  }
3170}

3172void ScExternalRefManager::Notify( SfxBroadcaster&, const SfxHint& rHint )
3173{
  const SfxEventHint* pEventHint = dynamic_cast<const SfxEventHint*>(&rHint);
  if ( !pEventHint )
      return;

  SfxEventHintId nEventId = pEventHint->GetEventId();
  switch ( nEventId )
  {
      case SfxEventHintId::PrepareCloseDoc:
          {
              std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(ScDocShell::GetActiveDialogParent(),
                                                         VclMessageType::Warning, VclButtonsType::Ok,
                                                         ScResId(STR_CLOSE_WITH_UNSAVED_REFSreinterpret_cast<char const *>("STR_CLOSE_WITH_UNSAVED_REFS"
 "\004" u8"This Document is referenced by another document and not yet saved. Closing it without saving will result in data loss."
))));
              xWarn->run();
          }
          break;
      case SfxEventHintId::SaveDocDone:
      case SfxEventHintId::SaveAsDocDone:
          {
              SfxObjectShell* pObjShell = static_cast<const SfxEventHint&>( rHint ).GetObjShell();
              transformUnsavedRefToSavedRef(pObjShell);
          }
          break;
      default:
          break;
  }
3199}

3201IMPL_LINK(ScExternalRefManager, TimeOutHdl, Timer*, pTimer, void)void ScExternalRefManager::LinkStubTimeOutHdl(void * instance
, Timer* data) { return static_cast<ScExternalRefManager *
>(instance)->TimeOutHdl(data); } void ScExternalRefManager
::TimeOutHdl(Timer* pTimer)
3202{
  if (pTimer == &maSrcDocTimer)
      purgeStaleSrcDocument(SRCDOC_LIFE_SPAN30000);
3205}

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

←

/home/maarten/src/libreoffice/core/include/tools/ref.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_TOOLS_REF_HXX
20#define INCLUDED_TOOLS_REF_HXX
21 
22#include <sal/config.h>
23#include <cassert>
24#include <tools/toolsdllapi.h>
25#include <utility>
26 
27/**
28   This implements similar functionality to boost::intrusive_ptr
29*/
30 
31namespace tools {
32 
33/** T must be a class that extends SvRefBase */
34template<typename T> class SAL_DLLPUBLIC_RTTI__attribute__ ((type_visibility("default"))) SvRef final {
35public:
36    SvRef(): pObj(nullptr) {}
37 
38    SvRef(SvRef&& rObj) noexcept
39    {
40        pObj = rObj.pObj;
41        rObj.pObj = nullptr;
42    }
43 
44    SvRef(SvRef const & rObj): pObj(rObj.pObj)
45    {
46        if (pObj != nullptr) pObj->AddNextRef();
47    }
48 
49    SvRef(T * pObjP): pObj(pObjP)
50    {
51        if (pObj != nullptr) pObj->AddFirstRef();
52    }
53 
54    ~SvRef()
55    {
56        if (pObj != nullptr) pObj->ReleaseRef();
12
←
Taking true branch→
13
←
Calling 'SvRefBase::ReleaseRef'→
20
←
Returning; memory was released→
57    }
58 
59    void clear()
60    {
61        if (pObj != nullptr) {
62            T * pRefObj = pObj;
63            pObj = nullptr;
64            pRefObj->ReleaseRef();
65        }
66    }
67 
68    SvRef & operator =(SvRef const & rObj)
69    {
70        if (rObj.pObj != nullptr) {
71            rObj.pObj->AddNextRef();
72        }
73        T * pRefObj = pObj;
74        pObj = rObj.pObj;
75        if (pRefObj != nullptr) {
76            pRefObj->ReleaseRef();
77        }
78        return *this;
79    }
80 
81    SvRef & operator =(SvRef && rObj)
82    {
83        if (pObj != nullptr) {
84            pObj->ReleaseRef();
85        }
86        pObj = rObj.pObj;
87        rObj.pObj = nullptr;
88        return *this;
89    }
90 
91    bool is()         const { return pObj != nullptr; }
92 
93    explicit operator bool() const { return is(); }
94 
95    T * get()         const { return pObj; }
96 
97    T * operator ->() const { assert(pObj != nullptr)(static_cast <bool> (pObj != nullptr) ? void (0) : __assert_fail
 ("pObj != nullptr", "/home/maarten/src/libreoffice/core/include/tools/ref.hxx"
, 97, __extension__ __PRETTY_FUNCTION__)); return pObj; }
98 
99    T & operator *()  const { assert(pObj != nullptr)(static_cast <bool> (pObj != nullptr) ? void (0) : __assert_fail
 ("pObj != nullptr", "/home/maarten/src/libreoffice/core/include/tools/ref.hxx"
, 99, __extension__ __PRETTY_FUNCTION__)); return *pObj; }
100 
101    bool operator ==(const SvRef<T> &rhs) const { return pObj == rhs.pObj; }
102    bool operator !=(const SvRef<T> &rhs) const { return !(*this == rhs); }
103 
104private:
105    T * pObj;
106};
107 
108/**
109 * This implements similar functionality to std::make_shared.
110 */
111template<typename T, typename... Args>
112SvRef<T> make_ref(Args&& ... args)
113{
114    return SvRef<T>(new T(std::forward<Args>(args)...));
115}
116 
117}
118 
119/** Classes that want to be referenced-counted via SvRef<T>, should extend this base class */
120class TOOLS_DLLPUBLIC__attribute__ ((visibility("default"))) SvRefBase
121{
122    // work around a clang 3.5 optimization bug: if the bNoDelete is *first*
123    // it mis-compiles "if (--nRefCount == 0)" and never deletes any object
124    unsigned int nRefCount : 31;
125    // the only reason this is not bool is because MSVC cannot handle mixed type bitfields
126    unsigned int bNoDelete : 1;
127 
128protected:
129    virtual         ~SvRefBase() COVERITY_NOEXCEPT_FALSE;
130 
131public:
132                    SvRefBase() : nRefCount(0), bNoDelete(1) {}
133                    SvRefBase(const SvRefBase &) : nRefCount(0), bNoDelete(1) {}
134 
135    SvRefBase &     operator=(const SvRefBase &) { return *this; }
136 
137    void            RestoreNoDelete()
138                    { bNoDelete = 1; }
139 
140    void            AddNextRef()
141                    {
142                        assert( nRefCount < (1 << 30) && "Do not add refs to dead objects" )(static_cast <bool> (nRefCount < (1 << 30) &&
 "Do not add refs to dead objects") ? void (0) : __assert_fail
 ("nRefCount < (1 << 30) && \"Do not add refs to dead objects\""
, "/home/maarten/src/libreoffice/core/include/tools/ref.hxx",
 142, __extension__ __PRETTY_FUNCTION__));
143                        ++nRefCount;
144                    }
145 
146    void            AddFirstRef()
147                    {
148                        assert( nRefCount < (1 << 30) && "Do not add refs to dead objects" )(static_cast <bool> (nRefCount < (1 << 30) &&
 "Do not add refs to dead objects") ? void (0) : __assert_fail
 ("nRefCount < (1 << 30) && \"Do not add refs to dead objects\""
, "/home/maarten/src/libreoffice/core/include/tools/ref.hxx",
 148, __extension__ __PRETTY_FUNCTION__));
149                        if( bNoDelete )
150                            bNoDelete = 0;
151                        ++nRefCount;
152                    }
153 
154    void            ReleaseRef()
155                    {
156                        assert( nRefCount >= 1)(static_cast <bool> (nRefCount >= 1) ? void (0) : __assert_fail
 ("nRefCount >= 1", "/home/maarten/src/libreoffice/core/include/tools/ref.hxx"
, 156, __extension__ __PRETTY_FUNCTION__));
14
←
Assuming field 'nRefCount' is >= 1→
15
←
'?' condition is true→
157                        if( --nRefCount == 0 && !bNoDelete)
16
←
Assuming the condition is true→
17
←
Assuming field 'bNoDelete' is 0→
18
←
Taking true branch→
158                        {
159                            // I'm not sure about the original purpose of this line, but right now
160                            // it serves the purpose that anything that attempts to do an AddRef()
161                            // after an object is deleted will trip an assert.
162                            nRefCount = 1 << 30;
163                            delete this;
19
←
Memory is released→
164                        }
165                    }
166 
167    unsigned int    GetRefCount() const
168                    { return nRefCount; }
169};
170 
171template<typename T>
172class SvCompatWeakBase;
173 
174/** SvCompatWeakHdl acts as an intermediary between SvCompatWeakRef<T> and T.
175*/
176template<typename T>
177class SvCompatWeakHdl final : public SvRefBase
178{
179    friend class SvCompatWeakBase<T>;
180    T* _pObj;
181 
182    SvCompatWeakHdl( T* pObj ) : _pObj( pObj ) {}
183 
184public:
185    void  ResetWeakBase( ) { _pObj = nullptr; }
186    T*    GetObj()        { return _pObj; }
187};
188 
189/** We only have one place that extends this, in include/sfx2/frame.hxx, class SfxFrame.
190    Its function is to notify the SvCompatWeakHdl when an SfxFrame object is deleted.
191*/
192template<typename T>
193class SvCompatWeakBase
194{
195    tools::SvRef< SvCompatWeakHdl<T> > _xHdl;
196 
197public:
198    /** Does not use initializer due to compiler warnings,
199        because the lifetime of the _xHdl object can exceed the lifetime of this class.
200     */
201    SvCompatWeakBase( T* pObj ) { _xHdl = new SvCompatWeakHdl<T>( pObj ); }
202 
203    ~SvCompatWeakBase() { _xHdl->ResetWeakBase(); }
204 
205    SvCompatWeakHdl<T>* GetHdl() { return _xHdl.get(); }
206};
207 
208/** We only have one weak reference in LO, in include/sfx2/frame.hxx, class SfxFrameWeak.
209*/
210template<typename T>
211class SAL_WARN_UNUSED__attribute__((warn_unused)) SvCompatWeakRef
212{
213    tools::SvRef< SvCompatWeakHdl<T> > _xHdl;
214public:
215    SvCompatWeakRef( ) {}
216    SvCompatWeakRef( T* pObj )
217                         {  if( pObj ) _xHdl = pObj->GetHdl(); }
218#if defined(__COVERITY__)
219    ~SvCompatWeakRef() COVERITY_NOEXCEPT_FALSE {}
220#endif
221    SvCompatWeakRef& operator = ( T * pObj )
222                         {  _xHdl = pObj ? pObj->GetHdl() : nullptr; return *this; }
223    bool          is() const
224                         { return _xHdl.is() && _xHdl->GetObj(); }
225    explicit operator bool() const { return is(); }
226    T*            operator -> () const
227                         { return _xHdl.is() ? _xHdl->GetObj() : nullptr; }
228    operator T* () const
229                         { return _xHdl.is() ? _xHdl->GetObj() : nullptr; }
230};
231 
232#endif
233 
234/* vim:set shiftwidth=4 softtabstop=4 expandtab: */