/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx
Warning:	line 1424, column 35 Called C++ object pointer is null
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 wrtww8.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 SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -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/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sw/source/filter/inc -I /home/maarten/src/libreoffice/core/sw/inc -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/oox/generated -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/sw/source/filter/ww8/wrtww8.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 <memory>
21#include <iostream>

23#include <com/sun/star/embed/ElementModes.hpp>
24#include <com/sun/star/embed/XStorage.hpp>
25#include <com/sun/star/frame/XModel.hpp>
26#include <com/sun/star/packages/XPackageEncryption.hpp>
27#include <com/sun/star/uno/XComponentContext.hpp>
28#include <unotools/ucbstreamhelper.hxx>
29#include <unotools/streamwrap.hxx>
30#include <algorithm>
31#include <map>
32#include <hintids.hxx>
33#include <string.h>
34#include <o3tl/safeint.hxx>
35#include <osl/endian.h>
36#include <sal/log.hxx>
37#include <docsh.hxx>
38#include <drawdoc.hxx>

40#include <unotools/fltrcfg.hxx>
41#include <sot/storage.hxx>
42#include <sfx2/docinf.hxx>
43#include <editeng/tstpitem.hxx>
44#include <svx/svdpage.hxx>
45#include <editeng/hyphenzoneitem.hxx>
46#include <filter/msfilter/classids.hxx>
47#include <filter/msfilter/msoleexp.hxx>
48#include <editeng/lrspitem.hxx>
49#include <editeng/ulspitem.hxx>
50#include <editeng/boxitem.hxx>
51#include <editeng/brushitem.hxx>
52#include <swtypes.hxx>
53#include <swrect.hxx>
54#include <swtblfmt.hxx>
55#include <fmtcntnt.hxx>
56#include <fmtpdsc.hxx>
57#include <fmtrowsplt.hxx>
58#include <frmatr.hxx>
59#include <../../core/inc/rootfrm.hxx>
60#include <doc.hxx>
61#include <IDocumentSettingAccess.hxx>
62#include <IDocumentDrawModelAccess.hxx>
63#include <IDocumentStylePoolAccess.hxx>
64#include <IDocumentStatistics.hxx>
65#include <IDocumentLayoutAccess.hxx>
66#include <IDocumentExternalData.hxx>
67#include <viewopt.hxx>
68#include <docary.hxx>
69#include <pam.hxx>
70#include <ndtxt.hxx>
71#include <shellio.hxx>
72#include <docstat.hxx>
73#include <pagedesc.hxx>
74#include <poolfmt.hxx>
75#include <IMark.hxx>
76#include <swtable.hxx>
77#include "wrtww8.hxx"
78#include "ww8par.hxx"
79#include <swmodule.hxx>
80#include <section.hxx>
81#include <fmtinfmt.hxx>
82#include <txtinet.hxx>
83#include <fmturl.hxx>
84#include <vcl/imap.hxx>
85#include <vcl/imapobj.hxx>
86#include <mdiexp.hxx>
87#include <strings.hrc>
88#include <fmtline.hxx>
89#include <fmtfsize.hxx>
90#include "sprmids.hxx"

92#include <comphelper/sequenceashashmap.hxx>
93#include <comphelper/processfactory.hxx>
94#include "writerhelper.hxx"
95#include "writerwordglue.hxx"
96#include "ww8attributeoutput.hxx"
97#include <xmloff/odffields.hxx>
98#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
99#include <com/sun/star/document/XDocumentProperties.hpp>
100#include <dbgoutsw.hxx>
101#include <sfx2/docfile.hxx>
102#include <sfx2/frame.hxx>
103#include <svl/stritem.hxx>
104#include <unotools/tempfile.hxx>
105#include <filter/msfilter/mscodec.hxx>
106#include <filter/msfilter/svxmsbas.hxx>
107#include <rtl/random.h>
108#include <vcl/svapp.hxx>
109#include <sfx2/docfilt.hxx>
110#include "WW8Sttbf.hxx"
111#include <editeng/charrotateitem.hxx>
112#include <svx/swframetypes.hxx>
113#include "WW8FibData.hxx"
114#include <numrule.hxx>
115#include <fmtclds.hxx>
116#include <rdfhelper.hxx>
117#include <fmtclbl.hxx>
118#include <iodetect.hxx>

120using namespace css;
121using namespace sw::util;
122using namespace sw::types;

124/** FKP - Formatted disK Page
125*/
126class WW8_WrFkp
127{
  sal_uInt8* pFkp;         // Fkp total ( first and only FCs and Sprms )
  sal_uInt8* pOfs;         // pointer to the offset area, later copied to pFkp
  ePLCFT ePlc;
  short nStartGrp;    // from here on grpprls
  short nOldStartGrp;
  sal_uInt8 nItemSize;
  sal_uInt8 nIMax;         // number of entry pairs
  sal_uInt8 nOldVarLen;
  bool bCombined;     // true : paste not allowed

  sal_uInt8 SearchSameSprm( sal_uInt16 nVarLen, const sal_uInt8* pSprms );

  WW8_WrFkp(const WW8_WrFkp&) = delete;
  WW8_WrFkp& operator=(const WW8_WrFkp&) = delete;

143public:
  WW8_WrFkp(ePLCFT ePl, WW8_FC nStartFc);
  ~WW8_WrFkp();
  bool Append( WW8_FC nEndFc, sal_uInt16 nVarLen, const sal_uInt8* pSprms );
  void Combine();
  void Write( SvStream& rStrm, SwWW8WrGrf& rGrf );

  bool IsEqualPos(WW8_FC nEndFc) const
  {   return !bCombined && nIMax && nEndFc == reinterpret_cast<sal_Int32*>(pFkp)[nIMax]; }
  void MergeToNew( short& rVarLen, sal_uInt8 *& pNewSprms );
  bool IsEmptySprm() const
  {   return !bCombined && nIMax && !nOldVarLen;  }
  void SetNewEnd( WW8_FC nEnd )
  {   reinterpret_cast<sal_Int32*>(pFkp)[nIMax] = nEnd; }

  WW8_FC GetStartFc() const;
  WW8_FC GetEndFc() const;

  sal_uInt8 *CopyLastSprms(sal_uInt8 &rLen);
162};

164// class WW8_WrPc collects all piece entries for one piece
165class WW8_WrPc
166{
  WW8_CP nStartCp;                    // Starting character position of the text
  WW8_FC nStartFc;                    // Starting file position of the text
  sal_uInt16 nStatus;                     // End of paragraph inside the piece?

171public:
  WW8_WrPc(WW8_FC nSFc, WW8_CP nSCp )
      : nStartCp( nSCp ), nStartFc( nSFc ), nStatus( 0x0040 )
  {}

  void SetStatus()                { nStatus = 0x0050; }
  sal_uInt16 GetStatus()  const       { return nStatus; }
  WW8_CP GetStartCp() const       { return nStartCp; }
  WW8_FC GetStartFc() const       { return nStartFc; }
180};

182typedef std::map<OUString,long> BKMKNames;
183typedef std::pair<bool,OUString> BKMK;
184typedef std::pair<long,BKMK> BKMKCP;
185typedef std::multimap<long,BKMKCP*> BKMKCPs;
186typedef BKMKCPs::iterator CPItr;

188class WW8_WrtBookmarks
189{
190private:
  /// Structure of one item inside this map: (startPos, (endPos, (a bool value?, bookmarkName)))
  BKMKCPs aSttCps;
  BKMKNames maSwBkmkNms;

  WW8_WrtBookmarks(WW8_WrtBookmarks const&) = delete;
  WW8_WrtBookmarks& operator=(WW8_WrtBookmarks const&) = delete;

198public:
  WW8_WrtBookmarks();
  ~WW8_WrtBookmarks();
  //! Add a new bookmark to the list OR add an end position to an existing bookmark.
  void Append( WW8_CP nStartCp, const OUString& rNm );
  //! Write out bookmarks to file.
  void Write( WW8Export& rWrt );
  //! Move existing field marks from one position to another.
  void MoveFieldMarks(WW8_CP nFrom, WW8_CP nTo);
207};

209WW8_WrtBookmarks::WW8_WrtBookmarks()
210{}

212WW8_WrtBookmarks::~WW8_WrtBookmarks()
213{
  for (auto& rEntry : aSttCps)
  {
      if (rEntry.second)
      {
          delete rEntry.second;
          rEntry.second = nullptr;
      }
  }
222}

224void WW8_WrtBookmarks::Append( WW8_CP nStartCp, const OUString& rNm)
225{
  std::pair<BKMKNames::iterator, bool> aResult = maSwBkmkNms.insert(std::pair<OUString,long>(rNm,0L));
  if (aResult.second)
  {
      BKMK aBK(false,rNm);
      BKMKCP* pBKCP = new BKMKCP(static_cast<long>(nStartCp),aBK);
      aSttCps.insert(std::pair<long,BKMKCP*>(nStartCp,pBKCP));
      aResult.first->second = static_cast<long>(nStartCp);
  }
  else
  {
      std::pair<CPItr,CPItr> aRange = aSttCps.equal_range(aResult.first->second);
      for (CPItr aItr = aRange.first;aItr != aRange.second;++aItr)
      {
          if (aItr->second && aItr->second->second.second == rNm)
          {
              if (aItr->second->second.first)
                  nStartCp--;
              aItr->second->first = static_cast<long>(nStartCp);
              break;
          }
      }
  }
248}

250void WW8_WrtBookmarks::Write( WW8Export& rWrt)
251{
  if (aSttCps.empty())
      return;
  long n;
  std::vector<OUString> aNames;
  SvMemoryStream aTempStrm1(65535,65535);
  SvMemoryStream aTempStrm2(65535,65535);

  BKMKCPs aEndCps;
  for (const auto& rEntry : aSttCps)
  {
      if (rEntry.second)
      {
          aEndCps.insert(std::pair<long,BKMKCP*>(rEntry.second->first, rEntry.second));
          aNames.push_back(rEntry.second->second.second);
          SwWW8Writer::WriteLong(aTempStrm1, rEntry.first);
      }
  }

  aTempStrm1.Seek(0);
  n = 0;
  for (const auto& rEntry : aEndCps)
  {
      if (rEntry.second)
      {
          rEntry.second->first = n;
          SwWW8Writer::WriteLong( aTempStrm2, rEntry.first);
      }
      ++n;
  }

  aTempStrm2.Seek(0);
  rWrt.WriteAsStringTable(aNames, rWrt.pFib->m_fcSttbfbkmk,rWrt.pFib->m_lcbSttbfbkmk);
  SvStream& rStrm = *rWrt.pTableStrm;
  rWrt.pFib->m_fcPlcfbkf = rStrm.Tell();
  rStrm.WriteStream( aTempStrm1 );
  SwWW8Writer::WriteLong(rStrm, rWrt.pFib->m_ccpText + rWrt.pFib->m_ccpTxbx);
  for (const auto& rEntry : aSttCps)
  {
      if (rEntry.second)
      {
          SwWW8Writer::WriteLong(rStrm, rEntry.second->first);
      }
  }
  rWrt.pFib->m_lcbPlcfbkf = rStrm.Tell() - rWrt.pFib->m_fcPlcfbkf;
  rWrt.pFib->m_fcPlcfbkl = rStrm.Tell();
  rStrm.WriteStream( aTempStrm2 );
  SwWW8Writer::WriteLong(rStrm, rWrt.pFib->m_ccpText + rWrt.pFib->m_ccpTxbx);
  rWrt.pFib->m_lcbPlcfbkl = rStrm.Tell() - rWrt.pFib->m_fcPlcfbkl;
300}

302void WW8_WrtBookmarks::MoveFieldMarks(WW8_CP nFrom, WW8_CP nTo)
303{
  std::pair<CPItr,CPItr> aRange = aSttCps.equal_range(nFrom);
  CPItr aItr = aRange.first;
  while (aItr != aRange.second)
  {
      if (aItr->second)
      {
          if (aItr->second->first == static_cast<long>(nFrom))
          {
              aItr->second->second.first = true;
              aItr->second->first = nTo;
          }
          aSttCps.insert(std::pair<long,BKMKCP*>(nTo,aItr->second));
          aItr->second = nullptr;
          aRange = aSttCps.equal_range(nFrom);
          aItr = aRange.first;
          continue;
      }
      ++aItr;
  }
323}

325/// Handles export of smart tags.
326class WW8_WrtFactoids
327{
  std::vector<WW8_CP> m_aStartCPs;
  std::vector<WW8_CP> m_aEndCPs;
  std::vector< std::map<OUString, OUString> > m_aStatements;

  WW8_WrtFactoids(WW8_WrtFactoids const&) = delete;
  WW8_WrtFactoids& operator=(WW8_WrtFactoids const&) = delete;

335public:
  WW8_WrtFactoids();
  void Append(WW8_CP nStartCp, WW8_CP nEndCp, const std::map<OUString, OUString>& rStatements);
  void Write(WW8Export& rWrt);
339};

341WW8_WrtFactoids::WW8_WrtFactoids()
342{
343}

345void WW8_WrtFactoids::Append(WW8_CP nStartCp, WW8_CP nEndCp, const std::map<OUString, OUString>& rStatements)
346{
  m_aStartCPs.push_back(nStartCp);
  m_aEndCPs.push_back(nEndCp);
  m_aStatements.push_back(rStatements);
350}

352void WW8_WrtFactoids::Write(WW8Export& rExport)
353{
  if (m_aStartCPs.empty())
      return;

  // Smart tags are otherwise removed by Word on saving.
  rExport.pDop->fEmbedFactoids = true;

  SvStream& rStream = *rExport.pTableStrm;

  rExport.pFib->m_fcSttbfBkmkFactoid = rStream.Tell();
  // Write SttbfBkmkFactoid.
  rStream.WriteUInt16(0xffff); // fExtend
  rStream.WriteUInt16(m_aStartCPs.size()); // cData
  rStream.WriteUInt16(0); // cbExtra

  for (size_t i = 0; i < m_aStartCPs.size(); ++i)
  {
      rStream.WriteUInt16(6); // cchData
      // Write FACTOIDINFO.
      rStream.WriteUInt32(i); // dwId
      rStream.WriteUInt16(0); // fSubEntry
      rStream.WriteUInt16(0); // fto
      rStream.WriteUInt32(0); // pfpb
  }
  rExport.pFib->m_lcbSttbfBkmkFactoid = rStream.Tell() - rExport.pFib->m_fcSttbfBkmkFactoid;

  rExport.pFib->m_fcPlcfBkfFactoid = rStream.Tell();
  for (const WW8_CP& rCP : m_aStartCPs)
      rStream.WriteInt32(rCP);
  rStream.WriteInt32(rExport.pFib->m_ccpText + rExport.pFib->m_ccpTxbx);

  // Write FBKFD.
  for (size_t i = 0; i < m_aStartCPs.size(); ++i)
  {
      rStream.WriteInt16(i); // ibkl
      rStream.WriteInt16(0); // bkc
      rStream.WriteInt16(1); // cDepth, 1 as start and end is the same.
  }

  rExport.pFib->m_lcbPlcfBkfFactoid = rStream.Tell() - rExport.pFib->m_fcPlcfBkfFactoid;

  rExport.pFib->m_fcPlcfBklFactoid = rStream.Tell();
  for (const WW8_CP& rCP : m_aEndCPs)
      rStream.WriteInt32(rCP);
  rStream.WriteInt32(rExport.pFib->m_ccpText + rExport.pFib->m_ccpTxbx);

  // Write FBKLD.
  for (size_t i = 0; i < m_aEndCPs.size(); ++i)
  {
      rStream.WriteInt16(i); // ibkf
      rStream.WriteInt16(0); // cDepth, 0 as does not overlap with any other smart tag.
  }
  rExport.pFib->m_lcbPlcfBklFactoid = rStream.Tell() - rExport.pFib->m_fcPlcfBklFactoid;

  rExport.pFib->m_fcFactoidData = rStream.Tell();
  // Write SmartTagData.
  MSOFactoidType aFactoidType;
  aFactoidType.m_nId = 1;
  aFactoidType.m_aUri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
  aFactoidType.m_aTag = "RDF";
  WW8SmartTagData aSmartTagData;
  aSmartTagData.m_aPropBagStore.m_aFactoidTypes.push_back(aFactoidType);

  std::set<OUString> aSet;
  for (const std::map<OUString, OUString>& rStatements : m_aStatements)
  {
      // Statements for a single text node.
      for (const auto& rPair : rStatements)
      {
          aSet.insert(rPair.first);
          aSet.insert(rPair.second);
      }
  }
  aSmartTagData.m_aPropBagStore.m_aStringTable.assign(aSet.begin(), aSet.end());
  for (const std::map<OUString, OUString>& rStatements : m_aStatements)
  {
      MSOPropertyBag aPropertyBag;
      aPropertyBag.m_nId = 1;
      for (const auto& rPair : rStatements)
      {
          MSOProperty aProperty;
          aProperty.m_nKey = std::distance(aSet.begin(), aSet.find(rPair.first));
          aProperty.m_nValue = std::distance(aSet.begin(), aSet.find(rPair.second));
          aPropertyBag.m_aProperties.push_back(aProperty);
      }
      aSmartTagData.m_aPropBags.push_back(aPropertyBag);
  }

  aSmartTagData.Write(rExport);
  rExport.pFib->m_lcbFactoidData = rStream.Tell() - rExport.pFib->m_fcFactoidData;
443}

445#define DEFAULT_STYLES_COUNT16 16

447// Names of the storage streams
448#define sMainStreamOUString("WordDocument") OUString("WordDocument")
449#define sCompObj"\1CompObj" "\1CompObj"

451static void WriteDop( WW8Export& rWrt )
452{
  WW8Dop& rDop = *rWrt.pDop;

  // i#78951#, store the value of unknown compatibility options
  rDop.SetCompatibilityOptions( rWrt.m_rDoc.getIDocumentSettingAccess().Getn32DummyCompatibilityOptions1());
  rDop.SetCompatibilityOptions2( rWrt.m_rDoc.getIDocumentSettingAccess().Getn32DummyCompatibilityOptions2());

  rDop.fNoLeading = !rWrt.m_rDoc.getIDocumentSettingAccess().get(DocumentSettingId::ADD_EXT_LEADING);
  rDop.fUsePrinterMetrics = !rWrt.m_rDoc.getIDocumentSettingAccess().get(DocumentSettingId::USE_VIRTUAL_DEVICE);

  // write default TabStop
  const SvxTabStopItem& rTabStop =
      DefaultItemGet<SvxTabStopItem>(rWrt.m_rDoc, RES_PARATR_TABSTOP);
  rDop.dxaTab = static_cast<sal_uInt16>(rTabStop[0].GetTabPos());

  // Zoom factor and type
  SwViewShell *pViewShell(rWrt.m_rDoc.getIDocumentLayoutAccess().GetCurrentViewShell());
  if (pViewShell)
  {
      switch ( pViewShell->GetViewOptions()->GetZoomType() )
      {
          case SvxZoomType::WHOLEPAGE: rDop.zkSaved = 1; break;
          case SvxZoomType::PAGEWIDTH: rDop.zkSaved = 2; break;
          case SvxZoomType::OPTIMAL:   rDop.zkSaved = 3; break;
          default:                 rDop.zkSaved = 0;
              rDop.wScaleSaved = pViewShell->GetViewOptions()->GetZoom();
              break;
      }
  }

  // Values from the DocumentStatistics (are definitely needed
  // for the DocStat fields)
  rDop.fWCFootnoteEdn = true; // because they are included in StarWriter

  const SwDocStat& rDStat = rWrt.m_rDoc.getIDocumentStatistics().GetDocStat();
  rDop.cWords = rDStat.nWord;
  rDop.cCh = rDStat.nChar;
  rDop.cPg = static_cast< sal_Int16 >(rDStat.nPage);
  rDop.cParas = rDStat.nPara;
  rDop.cLines = rDStat.nPara;

  SwDocShell *pDocShell(rWrt.m_rDoc.GetDocShell());
  OSL_ENSURE(pDocShell, "no SwDocShell")do { if (true && (!(pDocShell))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "494" ": "), "%s", "no SwDocShell"); } } while (false);
  uno::Reference<document::XDocumentProperties> xDocProps;
  uno::Reference<beans::XPropertySet> xProps;
  if ( pDocShell )
  {
      xProps.set(pDocShell->GetModel(), uno::UNO_QUERY);

      rDop.lKeyProtDoc = pDocShell->GetModifyPasswordHash();
  }

  if ((rWrt.pSepx && rWrt.pSepx->DocumentIsProtected()) ||
      rWrt.m_rDoc.getIDocumentSettingAccess().get(DocumentSettingId::PROTECT_FORM ) ||
      rDop.lKeyProtDoc != 0)
  {
      rDop.fProtEnabled =  true;
      // The password was ignored at import if forms protection was enabled,
      // so round-trip it since protection is still enabled.
      if ( rDop.lKeyProtDoc == 0 && xProps.is() )
      {
          comphelper::SequenceAsHashMap aPropMap( xProps->getPropertyValue("InteropGrabBag"));
          aPropMap.getValue("FormPasswordHash") >>= rDop.lKeyProtDoc;
      }
  }
  else
  {
      rDop.fProtEnabled = false;
  }

  if (!xDocProps.is())
  {
      rDop.dttmCreated = rDop.dttmRevised = rDop.dttmLastPrint = 0x45FBAC69;
  }
  else
  {
      ::util::DateTime uDT = xDocProps->getCreationDate();
      rDop.dttmCreated = sw::ms::DateTime2DTTM(DateTime(uDT));
      uDT = xDocProps->getModificationDate();
      rDop.dttmRevised = sw::ms::DateTime2DTTM(DateTime(uDT));
      uDT = xDocProps->getPrintDate();
      rDop.dttmLastPrint = sw::ms::DateTime2DTTM(DateTime(uDT));
  }

  // Also, the DocStat fields in headers, footers are not calculated correctly.
  // ( we do not have this fields! )

  // and also for the Headers and Footers
  rDop.cWordsFootnoteEnd   = rDStat.nWord;
  rDop.cChFootnoteEdn      = rDStat.nChar;
  rDop.cPgFootnoteEdn      = static_cast<sal_Int16>(rDStat.nPage);
  rDop.cParasFootnoteEdn   = rDStat.nPara;
  rDop.cLinesFootnoteEdn   = rDStat.nPara;

  rDop.fDontUseHTMLAutoSpacing = rWrt.m_rDoc.getIDocumentSettingAccess().get(DocumentSettingId::PARA_SPACE_MAX);

  rDop.fExpShRtn = !rWrt.m_rDoc.getIDocumentSettingAccess().get(DocumentSettingId::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK); // #i56856#

  rDop.Write( *rWrt.pTableStrm, *rWrt.pFib );
551}

553static int lcl_CmpBeginEndChars( const OUString& rSWStr,
  const sal_Unicode* pMSStr, int nMSStrByteLen )
555{
  nMSStrByteLen /= sizeof( sal_Unicode );
  if( nMSStrByteLen > rSWStr.getLength() )
      nMSStrByteLen = rSWStr.getLength()+1;
  nMSStrByteLen *= sizeof( sal_Unicode );

  return memcmp( rSWStr.getStr(), pMSStr, nMSStrByteLen );
562}

564/*
565Converts the OOo Asian Typography into a best fit match for Microsoft
566Asian typography. This structure is actually dumped to disk within the
567Dop Writer. Assumption is that rTypo is cleared to 0 on entry
568*/
569void WW8Export::ExportDopTypography(WW8DopTypography &rTypo)
570{
  static const sal_Unicode aLangNotBegin[4][WW8DopTypography::nMaxFollowing]=
  {
      //Japanese Level 1
      {
          0x0021, 0x0025, 0x0029, 0x002c, 0x002e, 0x003a, 0x003b, 0x003f,
          0x005d, 0x007d, 0x00a2, 0x00b0, 0x2019, 0x201d, 0x2030, 0x2032,
          0x2033, 0x2103, 0x3001, 0x3002, 0x3005, 0x3009, 0x300b, 0x300d,
          0x300f, 0x3011, 0x3015, 0x3041, 0x3043, 0x3045, 0x3047, 0x3049,
          0x3063, 0x3083, 0x3085, 0x3087, 0x308e, 0x309b, 0x309c, 0x309d,
          0x309e, 0x30a1, 0x30a3, 0x30a5, 0x30a7, 0x30a9, 0x30c3, 0x30e3,
          0x30e5, 0x30e7, 0x30ee, 0x30f5, 0x30f6, 0x30fb, 0x30fc, 0x30fd,
          0x30fe, 0xff01, 0xff05, 0xff09, 0xff0c, 0xff0e, 0xff1a, 0xff1b,
          0xff1f, 0xff3d, 0xff5d, 0xff61, 0xff63, 0xff64, 0xff65, 0xff67,
          0xff68, 0xff69, 0xff6a, 0xff6b, 0xff6c, 0xff6d, 0xff6e, 0xff6f,
          0xff70, 0xff9e, 0xff9f, 0xffe0
      },
      //Simplified Chinese
      {
          0x0021, 0x0029, 0x002c, 0x002e, 0x003a, 0x003b, 0x003f, 0x005d,
          0x007d, 0x00a8, 0x00b7, 0x02c7, 0x02c9, 0x2015, 0x2016, 0x2019,
          0x201d, 0x2026, 0x2236, 0x3001, 0x3002, 0x3003, 0x3005, 0x3009,
          0x300b, 0x300d, 0x300f, 0x3011, 0x3015, 0x3017, 0xff01, 0xff02,
          0xff07, 0xff09, 0xff0c, 0xff0e, 0xff1a, 0xff1b, 0xff1f, 0xff3d,
          0xff40, 0xff5c, 0xff5d, 0xff5e, 0xffe0
      },
      //Korean
      {
          0x0021, 0x0025, 0x0029, 0x002c, 0x002e, 0x003a, 0x003b, 0x003f,
          0x005d, 0x007d, 0x00a2, 0x00b0, 0x2019, 0x201d, 0x2032, 0x2033,
          0x2103, 0x3009, 0x300b, 0x300d, 0x300f, 0x3011, 0x3015, 0xff01,
          0xff05, 0xff09, 0xff0c, 0xff0e, 0xff1a, 0xff1b, 0xff1f, 0xff3d,
          0xff5d, 0xffe0
      },
      //Traditional Chinese
      {
          0x0021, 0x0029, 0x002c, 0x002e, 0x003a, 0x003b, 0x003f, 0x005d,
          0x007d, 0x00a2, 0x00b7, 0x2013, 0x2014, 0x2019, 0x201d, 0x2022,
          0x2025, 0x2026, 0x2027, 0x2032, 0x2574, 0x3001, 0x3002, 0x3009,
          0x300b, 0x300d, 0x300f, 0x3011, 0x3015, 0x301e, 0xfe30, 0xfe31,
          0xfe33, 0xfe34, 0xfe36, 0xfe38, 0xfe3a, 0xfe3c, 0xfe3e, 0xfe40,
          0xfe42, 0xfe44, 0xfe4f, 0xfe50, 0xfe51, 0xfe52, 0xfe54, 0xfe55,
          0xfe56, 0xfe57, 0xfe5a, 0xfe5c, 0xfe5e, 0xff01, 0xff09, 0xff0c,
          0xff0e, 0xff1a, 0xff1b, 0xff1f, 0xff5c, 0xff5d, 0xff64
      },
  };

  static const sal_Unicode aLangNotEnd[4][WW8DopTypography::nMaxLeading] =
  {
      //Japanese Level 1
      {
          0x0024, 0x0028, 0x005b, 0x005c, 0x007b, 0x00a3, 0x00a5, 0x2018,
          0x201c, 0x3008, 0x300a, 0x300c, 0x300e, 0x3010, 0x3014, 0xff04,
          0xff08, 0xff3b, 0xff5b, 0xff62, 0xffe1, 0xffe5
      },
      //Simplified Chinese
      {
          0x0028, 0x005b, 0x007b, 0x00b7, 0x2018, 0x201c, 0x3008, 0x300a,
          0x300c, 0x300e, 0x3010, 0x3014, 0x3016, 0xff08, 0xff0e, 0xff3b,
          0xff5b, 0xffe1, 0xffe5
      },
      //Korean
      {
          0x0028, 0x005b, 0x005c, 0x007b, 0x00a3, 0x00a5, 0x2018, 0x201c,
          0x3008, 0x300a, 0x300c, 0x300e, 0x3010, 0x3014, 0xff04, 0xff08,
          0xff3b, 0xff5b, 0xffe6
      },
      //Traditional Chinese
      {
          0x0028, 0x005b, 0x007b, 0x00a3, 0x00a5, 0x2018, 0x201c, 0x2035,
          0x3008, 0x300a, 0x300c, 0x300e, 0x3010, 0x3014, 0x301d, 0xfe35,
          0xfe37, 0xfe39, 0xfe3b, 0xfe3d, 0xfe3f, 0xfe41, 0xfe43, 0xfe59,
          0xfe5b, 0xfe5d, 0xff08, 0xff5b
      },
  };

  const i18n::ForbiddenCharacters *pForbidden = nullptr;
  const i18n::ForbiddenCharacters *pUseMe = nullptr;
  sal_uInt8 nUseReserved=0;
  int nNoNeeded=0;
  /*
  Now we have some minor difficult issues, to wit...
  a. MicroSoft Office can only store one set of begin and end characters in
  a given document, not one per language.
  b. StarOffice has only a concept of one set of begin and end characters for
  a given language, i.e. not the two levels of kinsoku in japanese

  What is unknown as yet is if our default begin and end chars for
  japanese, chinese tradition, chinese simplified and korean are different
  in Word and Writer. I already suspect that they are different between
  different version of word itself.

  So what have come up with is to simply see if any of the four languages
  in OOo have been changed away from OUR defaults, and if one has then
  export that. If more than one has in the future we may hack in something
  which examines our document properties to see which language is used the
  most and choose that, for now we choose the first and throw an ASSERT
  */

  /*Our default Japanese Level is 2, this is a special MS hack to set this*/
  rTypo.m_reserved2 = 1;

  for (rTypo.m_reserved1=8;rTypo.m_reserved1>0;rTypo.m_reserved1-=2)
  {
      pForbidden = m_rDoc.getIDocumentSettingAccess().getForbiddenCharacters(rTypo.GetConvertedLang(),
          false);
      if (nullptr != pForbidden)
      {
          int nIdx = (rTypo.m_reserved1-2)/2;
          if( lcl_CmpBeginEndChars( pForbidden->endLine,
                  aLangNotEnd[ nIdx ], sizeof(aLangNotEnd[ nIdx ]) ) ||
              lcl_CmpBeginEndChars( pForbidden->beginLine,
                  aLangNotBegin[ nIdx ], sizeof(aLangNotBegin[ nIdx ]) ) )
          {
              //One exception for Japanese, if it matches a level 1 we
              //can use one extra flag for that, rather than use a custom
              if (rTypo.GetConvertedLang() == LANGUAGE_JAPANESELanguageType(0x0411))
              {
                  if (
                        !lcl_CmpBeginEndChars
                          (
                              pForbidden->endLine,
                              WW8DopTypography::JapanNotEndLevel1,
                              WW8DopTypography::nMaxLeading * sizeof(sal_Unicode)
                          )
                      &&
                        !lcl_CmpBeginEndChars
                          (
                              pForbidden->beginLine,
                              WW8DopTypography::JapanNotBeginLevel1,
                              WW8DopTypography::nMaxFollowing * sizeof(sal_Unicode)
                          )
                      )
                  {
                      rTypo.m_reserved2 = 0;
                      continue;
                  }
              }

              if (!pUseMe)
              {
                  pUseMe = pForbidden;
                  nUseReserved = rTypo.m_reserved1;
                  rTypo.m_iLevelOfKinsoku = 2;
              }
              nNoNeeded++;
          }
      }
  }

  OSL_ENSURE( nNoNeeded<=1, "Example of unexportable forbidden chars" )do { if (true && (!(nNoNeeded<=1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "720" ": "), "%s", "Example of unexportable forbidden chars"
); } } while (false);
  rTypo.m_reserved1=nUseReserved;
  if (rTypo.m_iLevelOfKinsoku && pUseMe)
  {
      rTypo.m_cchFollowingPunct = msword_cast<sal_Int16>
          (pUseMe->beginLine.getLength());
      if (rTypo.m_cchFollowingPunct > WW8DopTypography::nMaxFollowing - 1)
          rTypo.m_cchFollowingPunct = WW8DopTypography::nMaxFollowing - 1;

      rTypo.m_cchLeadingPunct = msword_cast<sal_Int16>
          (pUseMe->endLine.getLength());
      if (rTypo.m_cchLeadingPunct > WW8DopTypography::nMaxLeading - 1)
          rTypo.m_cchLeadingPunct = WW8DopTypography::nMaxLeading -1;

      memcpy(rTypo.m_rgxchFPunct,pUseMe->beginLine.getStr(),
          (rTypo.m_cchFollowingPunct+1)*2);

      memcpy(rTypo.m_rgxchLPunct,pUseMe->endLine.getStr(),
          (rTypo.m_cchLeadingPunct+1)*2);
  }

  const IDocumentSettingAccess& rIDocumentSettingAccess = GetWriter().getIDocumentSettingAccess();

  rTypo.m_fKerningPunct = sal_uInt16(rIDocumentSettingAccess.get(DocumentSettingId::KERN_ASIAN_PUNCTUATION));
  rTypo.m_iJustification = sal_uInt16(m_rDoc.getIDocumentSettingAccess().getCharacterCompressionType());
745}

747// It can only be found something with this method, if it is used within
748// WW8_SwAttrIter::OutAttr() and WW8Export::OutputItemSet()
749const SfxPoolItem* MSWordExportBase::HasItem( sal_uInt16 nWhich ) const
750{
  const SfxPoolItem* pItem=nullptr;
  if (m_pISet)
  {
      // if write an EditEngine text, then the WhichIds are greater than
      // our own Ids. So the Id have to translate from our into the
      // EditEngine Range
      nWhich = sw::hack::GetSetWhichFromSwDocWhich(*m_pISet, m_rDoc, nWhich);
      if (nWhich && SfxItemState::SET != m_pISet->GetItemState(nWhich, true, &pItem))
          pItem = nullptr;
  }
  else if( m_pChpIter )
      pItem = m_pChpIter->HasTextItem( nWhich );
  else
  {
      OSL_ENSURE( false, "Where is my ItemSet / pChpIter ?" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "765" ": "), "%s", "Where is my ItemSet / pChpIter ?"); }
 } while (false);
      pItem = nullptr;
  }
  return pItem;
769}

771const SfxPoolItem& MSWordExportBase::GetItem(sal_uInt16 nWhich) const
772{
  assert((m_pISet || m_pChpIter) && "Where is my ItemSet / pChpIter ?")(static_cast <bool> ((m_pISet || m_pChpIter) &&
 "Where is my ItemSet / pChpIter ?") ? void (0) : __assert_fail
 ("(m_pISet || m_pChpIter) && \"Where is my ItemSet / pChpIter ?\""
, "/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
, 773, __extension__ __PRETTY_FUNCTION__));
  if (m_pISet)
  {
      // if write an EditEngine text, then the WhichIds are greater than
      // our own Ids. So the Id have to translate from our into the
      // EditEngine Range
      nWhich = sw::hack::GetSetWhichFromSwDocWhich(*m_pISet, m_rDoc, nWhich);
      OSL_ENSURE(nWhich != 0, "All broken, Impossible")do { if (true && (!(nWhich != 0))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "780" ": "), "%s", "All broken, Impossible"); } } while (
false);
      return m_pISet->Get(nWhich);
  }
  return m_pChpIter->GetItem( nWhich );
784}

786WW8_WrPlc1::WW8_WrPlc1( sal_uInt16 nStructSz )
  : pData( new sal_uInt8[ 16 * nStructSz ] ),
    nDataLen(16 * nStructSz),
    nStructSiz( nStructSz )
790{
791}

793WW8_WrPlc1::~WW8_WrPlc1()
794{
795}

797WW8_CP WW8_WrPlc1::Prev() const
798{
  bool b = !aPos.empty();
  OSL_ENSURE(b,"Prev called on empty list")do { if (true && (!(b))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "800" ": "), "%s", "Prev called on empty list"); } } while
 (false);
  return b ? aPos.back() : 0;
802}

804void WW8_WrPlc1::Append( WW8_CP nCp, const void* pNewData )
805{
  sal_uLong nInsPos = aPos.size() * nStructSiz;
  aPos.push_back( nCp );
  if( nDataLen < nInsPos + nStructSiz )
  {
      sal_uInt8* pNew = new sal_uInt8[ 2 * nDataLen ];
      memcpy( pNew, pData.get(), nDataLen );
      pData.reset(pNew);
      nDataLen *= 2;
  }
  memcpy( pData.get() + nInsPos, pNewData, nStructSiz );
816}

818void WW8_WrPlc1::Finish( sal_uLong nLastCp, sal_uLong nSttCp )
819{
  if( !aPos.empty() )
  {
      aPos.push_back( nLastCp );
      if( nSttCp )
          for(WW8_CP & rCp : aPos)
              rCp -= nSttCp;
  }
827}

829void WW8_WrPlc1::Write( SvStream& rStrm )
830{
  decltype(aPos)::size_type i;
  for( i = 0; i < aPos.size(); ++i )
      SwWW8Writer::WriteLong( rStrm, aPos[i] );
  if( i )
      rStrm.WriteBytes(pData.get(), (i-1) * nStructSiz);
836}

838// Class WW8_WrPlcField for fields

840void WW8_WrPlcField::Write( WW8Export& rWrt )
841{
  if( WW8_WrPlc1::Count() <= 1 )
      return;

  WW8_FC *pfc;
  sal_Int32 *plc;
  switch (nTextTyp)
  {
      case TXT_MAINTEXT:
          pfc = &rWrt.pFib->m_fcPlcffldMom;
          plc = &rWrt.pFib->m_lcbPlcffldMom;
          break;
      case TXT_HDFT:
          pfc = &rWrt.pFib->m_fcPlcffldHdr;
          plc = &rWrt.pFib->m_lcbPlcffldHdr;
          break;

      case TXT_FTN:
          pfc = &rWrt.pFib->m_fcPlcffldFootnote;
          plc = &rWrt.pFib->m_lcbPlcffldFootnote;
          break;

      case TXT_EDN:
          pfc = &rWrt.pFib->m_fcPlcffldEdn;
          plc = &rWrt.pFib->m_lcbPlcffldEdn;
          break;

      case TXT_ATN:
          pfc = &rWrt.pFib->m_fcPlcffldAtn;
          plc = &rWrt.pFib->m_lcbPlcffldAtn;
          break;

      case TXT_TXTBOX:
          pfc = &rWrt.pFib->m_fcPlcffldTxbx;
          plc = &rWrt.pFib->m_lcbPlcffldTxbx;
          break;

      case TXT_HFTXTBOX:
          pfc = &rWrt.pFib->m_fcPlcffldHdrTxbx;
          plc = &rWrt.pFib->m_lcbPlcffldHdrTxbx;
          break;

      default:
          pfc = plc = nullptr;
          break;
  }

  if( pfc && plc )
  {
      sal_uInt64 nFcStart = rWrt.pTableStrm->Tell();
      WW8_WrPlc1::Write( *rWrt.pTableStrm );
      *pfc = nFcStart;
      *plc = rWrt.pTableStrm->Tell() - nFcStart;
  }
895}

897void WW8_WrMagicTable::Write( WW8Export& rWrt )
898{
  if( WW8_WrPlc1::Count() <= 1 )
      return;
  sal_uLong nFcStart = rWrt.pTableStrm->Tell();
  WW8_WrPlc1::Write( *rWrt.pTableStrm );
  rWrt.pFib->m_fcPlcfTch = nFcStart;
  rWrt.pFib->m_lcbPlcfTch = rWrt.pTableStrm->Tell() - nFcStart;
905}

907void WW8_WrMagicTable::Append( WW8_CP nCp, sal_uLong nData)
908{
  /*
  Tell the undocumented table hack that everything between here and the last
  table position is non-table text, don't do it if the previous position is
  the same as this one, as that would be a region of 0 length
  */
  if ((!Count()) || (Prev() != nCp))
  {
      SVBT32 nLittle;
      UInt32ToSVBT32(nData,nLittle);
      WW8_WrPlc1::Append(nCp, nLittle);
  }
920}

922void SwWW8Writer::FillCount( SvStream& rStrm, sal_uLong nCount )
923{
  static const sal_uInt32 aNulls[16] =
  {
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 // 64 Byte
  };

  while (nCount > 64)
  {
      rStrm.WriteBytes(aNulls, 64); // in steps of 64-Byte
      nCount -= 64;
  }
  rStrm.WriteBytes(aNulls, nCount); // write the rest (0 .. 64 Bytes)
935}

937sal_uLong SwWW8Writer::FillUntil( SvStream& rStrm, sal_uLong nEndPos )
938{
  sal_uInt64 nCurPos = rStrm.Tell();
  if( !nEndPos )                          // nEndPos == 0 -> next Page
      nEndPos = (nCurPos + 0x1ff) & ~0x1ffUL;

  if( nEndPos > nCurPos )
      SwWW8Writer::FillCount( rStrm, nEndPos - nCurPos );
945#if OSL_DEBUG_LEVEL1 > 0
  else
      OSL_ENSURE( nEndPos == nCurPos, "Wrong FillUntil()" )do { if (true && (!(nEndPos == nCurPos))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "947" ": "), "%s", "Wrong FillUntil()"); } } while (false
);
948#endif
  return rStrm.Tell();
950}

952WW8_WrPlcPn::WW8_WrPlcPn(WW8Export& rWr, ePLCFT ePl, WW8_FC nStartFc)
  : rWrt(rWr)
  , nFkpStartPage(0)
  , ePlc(ePl)
956{
  m_Fkps.push_back(std::make_unique<WW8_WrFkp>(ePlc, nStartFc));
958}

960WW8_WrPlcPn::~WW8_WrPlcPn()
961{
962}

964sal_uInt8 *WW8_WrPlcPn::CopyLastSprms(sal_uInt8 &rLen)
965{
  WW8_WrFkp& rF = *m_Fkps.back();
  return rF.CopyLastSprms(rLen);
968}

970void WW8_WrPlcPn::AppendFkpEntry(WW8_FC nEndFc,short nVarLen,const sal_uInt8* pSprms)
971{
  WW8_WrFkp* pF = m_Fkps.back().get();

  // big sprm? build the sprmPHugePapx
  sal_uInt8* pNewSprms = const_cast<sal_uInt8*>(pSprms);
  sal_uInt8 aHugePapx[ 8 ];
  if (PAP == ePlc && 488 <= nVarLen)
  {
      sal_uInt8* p = aHugePapx;
      *p++ = *pSprms++;           // set style Id
      *p++ = *pSprms++;
      nVarLen -= 2;

      long nDataPos = rWrt.pDataStrm->Tell();
      SwWW8Writer::WriteShort( *rWrt.pDataStrm, nVarLen );
      rWrt.pDataStrm->WriteBytes(pSprms, nVarLen);

      Set_UInt16( p, 0x6646 );    // set SprmCode
      Set_UInt32( p, nDataPos );  // set startpos (FC) in the datastream
      nVarLen = static_cast< short >(p - aHugePapx);
      pSprms = pNewSprms = aHugePapx;
  }
  // if append at the same FC-EndPos and there are sprms, then get the old
  // sprms and erase it; they will append now with the new sprms
  else if( nVarLen && pF->IsEqualPos( nEndFc ))
      pF->MergeToNew( nVarLen, pNewSprms );
  // has the prev EndFC an empty sprm and the current is empty too, then
  // expand only the old EndFc to the new EndFc
  else if( !nVarLen && pF->IsEmptySprm() )
  {
      pF->SetNewEnd( nEndFc );
      return ;
  }

  bool bOk = pF->Append(nEndFc, nVarLen, pNewSprms);
  if( !bOk )
  {
      pF->Combine();
      pF = new WW8_WrFkp(ePlc, pF->GetEndFc()); // Start new Fkp == end of old Fkp

      m_Fkps.push_back(std::unique_ptr<WW8_WrFkp>(pF));
      if( !pF->Append( nEndFc, nVarLen, pNewSprms ) )
      {
          OSL_ENSURE( false, "Unable to insert Sprm" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1014" ": "), "%s", "Unable to insert Sprm"); } } while (
false);
      }
  }
  if( pNewSprms != pSprms )   //Merge to new has created a new block
      delete[] pNewSprms;
1019}

1021void WW8_WrPlcPn::WriteFkps()
1022{
  nFkpStartPage = static_cast<sal_uInt16>( SwWW8Writer::FillUntil( rWrt.Strm() ) >> 9 );

  for(const std::unique_ptr<WW8_WrFkp> & rp : m_Fkps)
  {
      rp->Write( rWrt.Strm(), *rWrt.m_pGrf );
  }

  if( CHP == ePlc )
  {
      rWrt.pFib->m_pnChpFirst = nFkpStartPage;
      rWrt.pFib->m_cpnBteChp = m_Fkps.size();
  }
  else
  {
      rWrt.pFib->m_pnPapFirst = nFkpStartPage;
      rWrt.pFib->m_cpnBtePap = m_Fkps.size();
  }
1040}

1042void WW8_WrPlcPn::WritePlc()
1043{
  sal_uInt64 nFcStart = rWrt.pTableStrm->Tell();
  decltype(m_Fkps)::size_type i;

  for (i = 0; i < m_Fkps.size(); ++i)
  {
      SwWW8Writer::WriteLong( *rWrt.pTableStrm,
                              m_Fkps[ i ]->GetStartFc() );
  }

  SwWW8Writer::WriteLong( *rWrt.pTableStrm,
                              m_Fkps[ i - 1 ]->GetEndFc() );

  // for every FKP output the page
  for (i = 0; i < m_Fkps.size(); ++i)
  {
      SwWW8Writer::WriteLong( *rWrt.pTableStrm, i + nFkpStartPage );
  }

  if( CHP == ePlc )
  {
      rWrt.pFib->m_fcPlcfbteChpx = nFcStart;
      rWrt.pFib->m_lcbPlcfbteChpx = rWrt.pTableStrm->Tell() - nFcStart;
  }
  else
  {
      rWrt.pFib->m_fcPlcfbtePapx = nFcStart;
      rWrt.pFib->m_lcbPlcfbtePapx = rWrt.pTableStrm->Tell() - nFcStart;
  }
1072}

1074WW8_WrFkp::WW8_WrFkp(ePLCFT ePl, WW8_FC nStartFc)
  : ePlc(ePl), nStartGrp(511), nOldStartGrp(511),
  nItemSize( ( CHP == ePl ) ? 1 : 13 ),
  nIMax(0), nOldVarLen(0), bCombined(false)
1078{
  pFkp = reinterpret_cast<sal_uInt8*>(new sal_Int32[128]);           // 512 Byte
  pOfs = reinterpret_cast<sal_uInt8*>(new sal_Int32[128]);           // 512 Byte
  memset( pFkp, 0, 4 * 128 );
  memset( pOfs, 0, 4 * 128 );
  reinterpret_cast<sal_Int32*>(pFkp)[0] = nStartFc;         // 0th entry FC at nStartFc
1084}

1086WW8_WrFkp::~WW8_WrFkp()
1087{
  delete[] reinterpret_cast<sal_Int32 *>(pFkp);
  delete[] reinterpret_cast<sal_Int32 *>(pOfs);
1090}

1092sal_uInt8 WW8_WrFkp::SearchSameSprm( sal_uInt16 nVarLen, const sal_uInt8* pSprms )
1093{
  if( 3 < nVarLen )
  {
      // if the sprms contained picture-references then never equal!
      for( sal_uInt8 n = static_cast< sal_uInt8 >(nVarLen - 1); 3 < n; --n )
          if( pSprms[ n ] == GRF_MAGIC_30x56 &&
              pSprms[ n-1 ] == GRF_MAGIC_20x34 &&
              pSprms[ n-2 ] == GRF_MAGIC_10x12 )
                  return 0;
  }

  short i;
  for( i = 0; i < nIMax; i++ )
  {
      sal_uInt8 nStart = pOfs[i * nItemSize];
      if( nStart )
      {                               // has Sprms
          const sal_uInt8* p = pFkp + ( static_cast<sal_uInt16>(nStart) << 1 );
          if( ( CHP == ePlc
                  ? (*p++ == nVarLen)
                  : ((static_cast<sal_uInt16>(*p++) << 1 ) == (( nVarLen+1) & 0xfffe)) )
              && !memcmp( p, pSprms, nVarLen ) )
                  return nStart;                      // found it
      }
  }
  return 0;           // didn't found it
1119}

1121sal_uInt8 *WW8_WrFkp::CopyLastSprms(sal_uInt8 &rLen)
1122{
  rLen=0;
  sal_uInt8 *pStart=nullptr,*pRet=nullptr;

  if (!bCombined)
      pStart = pOfs;
  else
      pStart = pFkp + ( nIMax + 1 ) * 4;

  sal_uInt8 nStart = *(pStart + (nIMax-1) * nItemSize);

  const sal_uInt8* p = pFkp + ( static_cast<sal_uInt16>(nStart) << 1 );

  if (!*p)
      p++;

  if (*p)
  {
      rLen = *p++;
      if (PAP == ePlc)
          rLen *= 2;
      pRet = new sal_uInt8[rLen];
      memcpy(pRet,p,rLen);
  }
  return pRet;
1147}

1149bool WW8_WrFkp::Append( WW8_FC nEndFc, sal_uInt16 nVarLen, const sal_uInt8* pSprms )
1150{
  assert((!nVarLen || pSprms) && "Item pointer missing")(static_cast <bool> ((!nVarLen || pSprms) && "Item pointer missing"
) ? void (0) : __assert_fail ("(!nVarLen || pSprms) && \"Item pointer missing\""
, "/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
, 1151, __extension__ __PRETTY_FUNCTION__));

  OSL_ENSURE( nVarLen < ( ( ePlc == PAP ) ? 497U : 502U ), "Sprms too long !" )do { if (true && (!(nVarLen < ( ( ePlc == PAP ) ? 497U
 : 502U )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1153" ": "), "%s", "Sprms too long !"); } } while (false
);

  if( bCombined )
  {
      OSL_ENSURE( false, "Fkp::Append: Fkp is already combined" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1157" ": "), "%s", "Fkp::Append: Fkp is already combined"
); } } while (false);
      return false;
  }
  sal_Int32 n = reinterpret_cast<sal_Int32*>(pFkp)[nIMax];        // last entry
  if( nEndFc <= n )
  {
      OSL_ENSURE( nEndFc >= n, "+Fkp: FC backwards" )do { if (true && (!(nEndFc >= n))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1163" ": "), "%s", "+Fkp: FC backwards"); } } while (false
);
      OSL_ENSURE( !nVarLen || !pSprms || nEndFc != n,do { if (true && (!(!nVarLen || !pSprms || nEndFc != n
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1165" ": "), "%s", "+Fkp: used same FC multiple times")
; } } while (false)
                                  "+Fkp: used same FC multiple times" )do { if (true && (!(!nVarLen || !pSprms || nEndFc != n
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1165" ": "), "%s", "+Fkp: used same FC multiple times")
; } } while (false);
                      // same FC without Sprm is ignored without grumbling

      return true;    // ignore (do not create a new Fkp)
  }

  sal_uInt8 nOldP = nVarLen ? SearchSameSprm( nVarLen, pSprms ) : 0;
                                          // Combine equal entries
  short nOffset=0, nPos = nStartGrp;
  if (nVarLen && !nOldP)
  {
      nPos = PAP == ePlc
              ? ( 13 == nItemSize     // HACK: PAP and bWrtWW8 !!
                   ? (nStartGrp & 0xFFFE ) - nVarLen - 1
                   : (nStartGrp - (((nVarLen + 1) & 0xFFFE)+1)) & 0xFFFE )
              : ((nStartGrp - nVarLen - 1) & 0xFFFE);
      if( nPos < 0 )
          return false;           // doesn't fit at all
      nOffset = nPos;             // save offset (can also be uneven!)
      nPos &= 0xFFFE;             // Pos for Sprms ( gerade Pos )
  }

  if( o3tl::make_unsigned(nPos) <= ( nIMax + 2U ) * 4U + ( nIMax + 1U ) * nItemSize )
                                          // does it fits after the CPs and offsets?
      return false;                       // no

  reinterpret_cast<sal_Int32*>(pFkp)[nIMax + 1] = nEndFc;     // insert FC

  nOldVarLen = static_cast<sal_uInt8>(nVarLen);
  if( nVarLen && !nOldP )
  {               // insert it for real
      nOldStartGrp = nStartGrp;

      nStartGrp = nPos;
      pOfs[nIMax * nItemSize] = static_cast<sal_uInt8>( nStartGrp >> 1 );
                                          // insert (start-of-data >> 1)
      sal_uInt8 nCnt = static_cast< sal_uInt8 >(CHP == ePlc
                      ? ( nVarLen < 256 ) ? static_cast<sal_uInt8>(nVarLen) : 255
                      : ( ( nVarLen + 1 ) >> 1 ));

      pFkp[ nOffset ] = nCnt;                     // Enter data length
      memcpy( pFkp + nOffset + 1, pSprms, nVarLen );  // store Sprms
  }
  else
  {
      // do not enter for real ( no Sprms or recurrence )
      // start-of-data 0 ( no data ) or recurrence
      pOfs[nIMax * nItemSize] = nOldP;
  }
  nIMax++;
  return true;
1216}

1218void WW8_WrFkp::Combine()
1219{
  if( bCombined )
      return;
  if( nIMax )
      memcpy( pFkp + ( nIMax + 1 ) * 4, pOfs, nIMax * nItemSize );
  delete[] pOfs;
  pOfs = nullptr;
  pFkp[511] = nIMax;
  bCombined = true;

1229#if defined OSL_BIGENDIAN           // only the FCs will be rotated here
  sal_uInt16 i;                   // the Sprms must be rotated elsewhere

  sal_uInt32* p;
  for( i = 0, p = (sal_uInt32*)pFkp; i <= nIMax; i++, p++ )
      *p = OSL_SWAPDWORD( *p )((sal_uInt32)((((sal_uInt16)((sal_uInt16)((((sal_uInt8)(((sal_uInt16
)(((sal_uInt16)(((sal_uInt32)(*p) >> 16) & 0xFFFF))
) >> 8) & 0xFF))) & 0xFF) | (((sal_uInt16)(((sal_uInt8
)((sal_uInt16)(((sal_uInt16)(((sal_uInt32)(*p) >> 16) &
 0xFFFF))) & 0xFF))) & 0xFF) << 8)))) & 0xFFFF
) | (((sal_uInt32)(((sal_uInt16)((sal_uInt16)((((sal_uInt8)((
(sal_uInt16)(((sal_uInt16)((sal_uInt32)(*p) & 0xFFFF))) >>
 8) & 0xFF))) & 0xFF) | (((sal_uInt16)(((sal_uInt8)((
sal_uInt16)(((sal_uInt16)((sal_uInt32)(*p) & 0xFFFF))) &
 0xFF))) & 0xFF) << 8)))) & 0xFFFF) << 16
));
1235#endif // ifdef OSL_BIGENDIAN
1236}

1238void WW8_WrFkp::Write( SvStream& rStrm, SwWW8WrGrf& rGrf )
1239{
  Combine();                      // If not already combined

  sal_uInt8* p;               //  search magic for nPicLocFc
  sal_uInt8* pEnd = pFkp + nStartGrp;
  for( p = pFkp + 511 - 4; p >= pEnd; p-- )
  {
      if( *p != GRF_MAGIC_10x12 )     // search for signature 0x12 0x34 0x56 0xXX
          continue;
      if( *(p+1) != GRF_MAGIC_20x34 )
          continue;
      if( *(p+2) != GRF_MAGIC_30x56 )
          continue;

      SVBT32 nPos;                // signature found
      UInt32ToSVBT32( rGrf.GetFPos(), nPos );   // FilePos the graphics
      memcpy( p, nPos, 4 );       // patch FilePos over the signature
  }
  rStrm.WriteBytes(pFkp, 512);
1258}

1260void WW8_WrFkp::MergeToNew( short& rVarLen, sal_uInt8 *& rpNewSprms )
1261{
  sal_uInt8 nStart = pOfs[ (nIMax-1) * nItemSize ];
  if( !nStart )
      return;

1266// has Sprms
  sal_uInt8* p = pFkp + ( static_cast<sal_uInt16>(nStart) << 1 );

  // old and new equal? Then copy only one into the new sprms
  if( nOldVarLen == rVarLen && !memcmp( p+1, rpNewSprms, nOldVarLen ))
  {
      sal_uInt8* pNew = new sal_uInt8[ nOldVarLen ];
      memcpy( pNew, p+1, nOldVarLen );
      rpNewSprms = pNew;
  }
  else
  {
      sal_uInt8* pNew = new sal_uInt8[ nOldVarLen + rVarLen ];
      memcpy( pNew, p+1, nOldVarLen );
      memcpy( pNew + nOldVarLen, rpNewSprms, rVarLen );

      rpNewSprms = pNew;
      rVarLen = rVarLen + nOldVarLen;
  }
  --nIMax;
  // if this Sprms don't used from others, remove it
  bool bFnd = false;
  for (sal_uInt16 n = 0; n < nIMax; ++n)
  {
      if (nStart == pOfs[n * nItemSize])
      {
          bFnd = true;
          break;
      }
  }
  if (!bFnd)
  {
      nStartGrp = nOldStartGrp;
      memset( p, 0, nOldVarLen+1 );
  }
1301}

1303WW8_FC WW8_WrFkp::GetStartFc() const
1304{
  // when bCombined, then the array beginning with pFkp is already byte-swapped
  // to LittleEndian, so to extract the start and end positions they must
  // be swapped back.
  if( bCombined )
      return SVBT32ToUInt32( pFkp );        // 0. Element
  return reinterpret_cast<sal_Int32*>(pFkp)[0];
1311}

1313WW8_FC WW8_WrFkp::GetEndFc() const
1314{
  if( bCombined )
      return SVBT32ToUInt32( &(pFkp[nIMax*4]) );    // nIMax-th SVBT32-Element
  return reinterpret_cast<sal_Int32*>(pFkp)[nIMax];
1318}

1320// Method for managing the piece table
1321WW8_WrPct::WW8_WrPct(WW8_FC nfcMin)
  : nOldFc(nfcMin)
1323{
  AppendPc(nOldFc);
1325}

1327WW8_WrPct::~WW8_WrPct()
1328{
1329}

1331// Fill the piece and create a new one
1332void WW8_WrPct::AppendPc(WW8_FC nStartFc)
1333{
  WW8_CP nStartCp = nStartFc - nOldFc;    // subtract the beginning of the text
  if ( !nStartCp && !m_Pcts.empty())
  {
      OSL_ENSURE(1 == m_Pcts.size(), "empty Piece!")do { if (true && (!(1 == m_Pcts.size()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1337" ": "), "%s", "empty Piece!"); } } while (false);
      m_Pcts.pop_back();
  }

  nOldFc = nStartFc;                      // remember StartFc as old

  nStartCp >>= 1;     // for Unicode: number of characters / 2

  if (!m_Pcts.empty())
  {
      nStartCp += m_Pcts.back()->GetStartCp();
  }

  m_Pcts.push_back(std::make_unique<WW8_WrPc>(nStartFc, nStartCp));
1351}

1353void WW8_WrPct::WritePc( WW8Export& rWrt )
1354{
  sal_uInt64 nPctStart;
  sal_uLong nOldPos, nEndPos;

  nPctStart = rWrt.pTableStrm->Tell();                    // Start piece table
  rWrt.pTableStrm->WriteChar( char(0x02) );                       // Status byte PCT
  nOldPos = nPctStart + 1;                                // remember Position
  SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );          // then the length

  for (auto const& it : m_Pcts) // ranges
  {
      SwWW8Writer::WriteLong( *rWrt.pTableStrm, it->GetStartCp() );
  }

  // calculate the last Pos
  sal_uLong nStartCp = rWrt.pFib->m_fcMac - nOldFc;
  nStartCp >>= 1;             // For Unicode: number of characters / 2
  nStartCp += m_Pcts.back()->GetStartCp();
  SwWW8Writer::WriteLong( *rWrt.pTableStrm, nStartCp );

  // piece references
  for (auto const& it : m_Pcts)
  {
      SwWW8Writer::WriteShort(*rWrt.pTableStrm, it->GetStatus());
      SwWW8Writer::WriteLong(*rWrt.pTableStrm, it->GetStartFc());
      SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0);          // PRM=0
  }

  // entries in the FIB
  rWrt.pFib->m_fcClx = nPctStart;
  nEndPos = rWrt.pTableStrm->Tell();
  rWrt.pFib->m_lcbClx = nEndPos - nPctStart;

  // and register the length as well
  SwWW8Writer::WriteLong( *rWrt.pTableStrm, nOldPos,
                          nEndPos - nPctStart-5 );

1391}

1393void WW8_WrPct::SetParaBreak()
1394{
  OSL_ENSURE( !m_Pcts.empty(), "SetParaBreak : m_Pcts.empty()" )do { if (true && (!(!m_Pcts.empty()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1395" ": "), "%s", "SetParaBreak : m_Pcts.empty()"); } }
 while (false);
  m_Pcts.back()->SetStatus();
1397}

1399WW8_CP WW8_WrPct::Fc2Cp( sal_uLong nFc ) const
1400{
  OSL_ENSURE( nFc >= o3tl::make_unsigned(nOldFc), "FilePos lies in front of last piece" )do { if (true && (!(nFc >= o3tl::make_unsigned(nOldFc
)))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1401" ": "), "%s", "FilePos lies in front of last piece"
); } } while (false);
  OSL_ENSURE( ! m_Pcts.empty(), "Fc2Cp no piece available" )do { if (true && (!(! m_Pcts.empty()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1402" ": "), "%s", "Fc2Cp no piece available"); } } while
 (false);

  nFc -= nOldFc;
  nFc /= 2; // Unicode
  return nFc + m_Pcts.back()->GetStartCp();
1407}

1409void WW8Export::AppendBookmarks( const SwTextNode& rNd, sal_Int32 nCurrentPos, sal_Int32 nLen )
1410{
  std::vector< const ::sw::mark::IMark* > aArr;
  sal_uInt16 nContent;
  const sal_Int32 nCurrentEnd = nCurrentPos + nLen;
  if( !GetWriter().GetBookmarks( rNd, nCurrentPos, nCurrentEnd, aArr ))
1
Assuming the condition is false→
2
←
Taking false branch→
      return;

  sal_uLong nNd = rNd.GetIndex(), nSttCP = Fc2Cp( Strm().Tell() );
  for(const ::sw::mark::IMark* p : aArr)
  {
      const ::sw::mark::IMark& rBkmk = *p;
3
←
'rBkmk' initialized here→
      if(dynamic_cast< const ::sw::mark::IFieldmark *>(&rBkmk))
4
←
Assuming pointer value is null→
5
←
Taking false branch→
          continue;

      const SwPosition* pPos = &rBkmk.GetMarkPos();
6
←
Called C++ object pointer is null
      const SwPosition* pOPos = nullptr;
      if(rBkmk.IsExpanded())
          pOPos = &rBkmk.GetOtherMarkPos();
      if( pOPos && pOPos->nNode == pPos->nNode &&
          pOPos->nContent < pPos->nContent )
      {
          pPos = pOPos;
          pOPos = &rBkmk.GetMarkPos();
      }

      if( !pOPos || ( nNd == pPos->nNode.GetIndex() &&
          ( nContent = pPos->nContent.GetIndex() ) >= nCurrentPos &&
          nContent < nCurrentEnd ) )
      {
          sal_uLong nCp = nSttCP + pPos->nContent.GetIndex() - nCurrentPos;
          m_pBkmks->Append(nCp, BookmarkToWord(rBkmk.GetName()));
      }
      if( pOPos && nNd == pOPos->nNode.GetIndex() &&
          ( nContent = pOPos->nContent.GetIndex() ) >= nCurrentPos &&
          nContent < nCurrentEnd )
      {
          sal_uLong nCp = nSttCP + pOPos->nContent.GetIndex() - nCurrentPos;
          m_pBkmks->Append(nCp, BookmarkToWord(rBkmk.GetName()));
      }
  }
1450}

1452void WW8Export::AppendAnnotationMarks(const SwWW8AttrIter& rAttrs, sal_Int32 nCurrentPos, sal_Int32 nLen)
1453{
  IMarkVector aMarks;
  if (GetAnnotationMarks(rAttrs, nCurrentPos, nCurrentPos + nLen, aMarks))
  {
      for (const sw::mark::IMark* pMark : aMarks)
      {
          const sal_Int32 nStart = pMark->GetMarkStart().nContent.GetIndex();
          if (nStart == nCurrentPos)
          {
              m_pAtn->AddRangeStartPosition(pMark->GetName(), Fc2Cp(Strm().Tell()),
                                            !rAttrs.HasFlysAt(nCurrentPos));
          }
      }
  }
1467}

1469void WW8Export::AppendSmartTags(SwTextNode& rTextNode)
1470{
  std::map<OUString, OUString> aStatements = SwRDFHelper::getTextNodeStatements("urn:bails", rTextNode);
  if (!aStatements.empty())
  {
      WW8_CP nCP = Fc2Cp(Strm().Tell());
      m_pFactoids->Append(nCP, nCP, aStatements);
  }
1477}

1479void WW8Export::MoveFieldMarks(WW8_CP nFrom, WW8_CP nTo)
1480{
  m_pBkmks->MoveFieldMarks(nFrom, nTo);
1482}

1484void WW8Export::AppendBookmark( const OUString& rName )
1485{
  sal_uLong nSttCP = Fc2Cp( Strm().Tell() );
  m_pBkmks->Append( nSttCP, rName );
1488}

1490void WW8Export::AppendBookmarkEndWithCorrection( const OUString& rName )
1491{
  sal_uLong nEndCP = Fc2Cp( Strm().Tell() );
  m_pBkmks->Append( nEndCP - 1, rName );
1494}

1496std::unique_ptr<SvxBrushItem> MSWordExportBase::getBackground()
1497{
  const SwFrameFormat &rFormat = m_rDoc.GetPageDesc(0).GetMaster();
  std::unique_ptr<SvxBrushItem> aBrush = std::make_unique<SvxBrushItem>(RES_BACKGROUND);
  SfxItemState eState = rFormat.GetBackgroundState(aBrush);

  if (SfxItemState::SET == eState)
  {
      // The 'color' is set for the first page style - take it and use it as the background color of the entire DOCX
      if (aBrush->GetColor() != COL_AUTO)
          return aBrush;
  }
  return nullptr;
1509}

1511// #i120928 collect all the graphics of bullets applied to paragraphs
1512int MSWordExportBase::CollectGrfsOfBullets()
1513{
  m_vecBulletPic.clear();

  size_t nCountRule = m_rDoc.GetNumRuleTable().size();
  for (size_t n = 0; n < nCountRule; ++n)
  {
      const SwNumRule &rRule = *( m_rDoc.GetNumRuleTable().at(n) );
      sal_uInt16 nLevels = rRule.IsContinusNum() ? 1 : 9;
      for (sal_uInt16 nLvl = 0; nLvl < nLevels; ++nLvl)
      {
          const SwNumFormat &rFormat = rRule.Get(nLvl);
          if (SVX_NUM_BITMAP != rFormat.GetNumberingType())
          {
              continue;
          }
          const Graphic *pGraf = rFormat.GetBrush()? rFormat.GetBrush()->GetGraphic():nullptr;
          if ( pGraf )
          {
              bool bHas = false;
              for (const Graphic* p : m_vecBulletPic)
              {
                  if (p->GetChecksum() == pGraf->GetChecksum())
                  {
                      bHas = true;
                      break;
                  }
              }
              if (!bHas)
              {
                  Size aSize(pGraf->GetPrefSize());
                  if (0 != aSize.Height() && 0 != aSize.Width())
                     m_vecBulletPic.push_back(pGraf);
              }
          }
      }
  }

  return m_vecBulletPic.size();
1551}

1553void MSWordExportBase::BulletDefinitions()
1554{
  for (size_t i = 0; i < m_vecBulletPic.size(); ++i)
  {
      const MapMode aMapMode(MapUnit::MapTwip);
      const Graphic& rGraphic = *m_vecBulletPic[i];
      Size aSize(rGraphic.GetPrefSize());
      if (MapUnit::MapPixel == rGraphic.GetPrefMapMode().GetMapUnit())
          aSize = Application::GetDefaultDevice()->PixelToLogic(aSize, aMapMode);
      else
          aSize = OutputDevice::LogicToLogic(aSize,rGraphic.GetPrefMapMode(), aMapMode);

      if (0 != aSize.Height() && 0 != aSize.Width())
          AttrOutput().BulletDefinition(i, rGraphic, aSize);
  }
1568}

1570//Export Graphic of Bullets
1571void WW8Export::ExportGrfBullet(const SwTextNode& rNd)
1572{
  int nCount = CollectGrfsOfBullets();
  if (nCount > 0)
  {
      SwPosition aPos(rNd);
      OUString aPicBullets("_PictureBullets");
      AppendBookmark(aPicBullets);
      for (int i = 0; i < nCount; i++)
      {
          ww8::Frame aFrame(*(m_vecBulletPic[i]), aPos);
          OutGrfBullets(aFrame);
      }
      AppendBookmark(aPicBullets);
  }
1586}

1588static sal_uInt8 nAttrMagicIdx = 0;
1589void WW8Export::OutGrfBullets(const ww8::Frame & rFrame)
1590{
  if ( !m_pGrf || !m_pChpPlc || !pO )
      return;

  m_pGrf->Insert(rFrame);
  m_pChpPlc->AppendFkpEntry( Strm().Tell(), pO->size(), pO->data() );
  pO->clear();
  // if links...
  WriteChar( char(1) );

  sal_uInt8 aArr[ 22 ];
  sal_uInt8* pArr = aArr;

  // sprmCFSpec
  Set_UInt16( pArr, 0x855 );
  Set_UInt8( pArr, 1 );

  Set_UInt16( pArr, 0x083c );
  Set_UInt8( pArr, 0x81 );

  // sprmCPicLocation
  Set_UInt16( pArr, 0x6a03 );
  Set_UInt32( pArr, GRF_MAGIC_3210x563412L );

  //extern  nAttrMagicIdx;
  --pArr;
  Set_UInt8( pArr, nAttrMagicIdx++ );
  m_pChpPlc->AppendFkpEntry( Strm().Tell(), static_cast< short >(pArr - aArr), aArr );
1618}

1620int MSWordExportBase::GetGrfIndex(const SvxBrushItem& rBrush)
1621{
  int nIndex = -1;

  const Graphic* pGraphic = rBrush.GetGraphic();
  if (pGraphic)
  {
      for (size_t i = 0; i < m_vecBulletPic.size(); ++i)
      {
          if (m_vecBulletPic[i]->GetChecksum() == pGraphic->GetChecksum())
          {
              nIndex = i;
              break;
          }
      }
  }

  return nIndex;
1638}

1640void WW8_WrtRedlineAuthor::Write( Writer& rWrt )
1641{
  WW8Export & rWW8Wrt = *(static_cast<SwWW8Writer&>(rWrt).m_pExport);
  rWW8Wrt.WriteAsStringTable(maAuthors, rWW8Wrt.pFib->m_fcSttbfRMark,
      rWW8Wrt.pFib->m_lcbSttbfRMark);
1645}

1647sal_uInt16 WW8Export::AddRedlineAuthor( std::size_t nId )
1648{
  if( !m_pRedlAuthors )
  {
      m_pRedlAuthors = new WW8_WrtRedlineAuthor;
      m_pRedlAuthors->AddName("Unknown");
  }
  return m_pRedlAuthors->AddName( SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetRedlineAuthor( nId ) );
1655}

1657void WW8Export::WriteAsStringTable(const std::vector<OUString>& rStrings,
  sal_Int32& rfcSttbf, sal_Int32& rlcbSttbf)
1659{
  sal_uInt16 n, nCount = static_cast< sal_uInt16 >(rStrings.size());
  if( !nCount )
      return;

  // we have some Redlines found in the document -> the
  // Author Name Stringtable
  SvStream& rStrm = *pTableStrm;
  rfcSttbf = rStrm.Tell();
  SwWW8Writer::WriteShort( rStrm, -1 );
  SwWW8Writer::WriteLong( rStrm, nCount );
  for( n = 0; n < nCount; ++n )
  {
      const OUString& rNm = rStrings[n];
      SwWW8Writer::WriteShort( rStrm, rNm.getLength() );
      SwWW8Writer::WriteString16(rStrm, rNm, false);
  }
  rlcbSttbf = rStrm.Tell() - rfcSttbf;
1677}

1679// WriteShort() sets at FilePos nPos the value nVal and seeks to the old
1680// FilePos. Used to insert lengths after the fact.
1681void SwWW8Writer::WriteShort( SvStream& rStrm, sal_uLong nPos, sal_Int16 nVal )
1682{
  sal_uInt64 nOldPos = rStrm.Tell();       // remember Pos
  rStrm.Seek( nPos );
  SwWW8Writer::WriteShort( rStrm, nVal );
  rStrm.Seek( nOldPos );
1687}

1689void SwWW8Writer::WriteLong( SvStream& rStrm, sal_uLong nPos, sal_Int32 nVal )
1690{
  sal_uInt64 nOldPos = rStrm.Tell();       // remember Pos
  rStrm.Seek( nPos );
  SwWW8Writer::WriteLong( rStrm, nVal );
  rStrm.Seek( nOldPos );
1695}

1697void SwWW8Writer::InsUInt16(ww::bytes &rO, sal_uInt16 n)
1698{
  SVBT16 nL;
  ShortToSVBT16( n, nL );
  rO.push_back(nL[0]);
  rO.push_back(nL[1]);
1703}

1705void SwWW8Writer::InsUInt32(ww::bytes &rO, sal_uInt32 n)
1706{
  SVBT32 nL;
  UInt32ToSVBT32( n, nL );
  rO.push_back(nL[0]);
  rO.push_back(nL[1]);
  rO.push_back(nL[2]);
  rO.push_back(nL[3]);
1713}

1715void SwWW8Writer::InsAsString16(ww::bytes &rO, const OUString& rStr)
1716{
  const sal_Unicode* pStr = rStr.getStr();
  for (sal_Int32 n = 0, nLen = rStr.getLength(); n < nLen; ++n, ++pStr)
      SwWW8Writer::InsUInt16( rO, *pStr );
1720}

1722void SwWW8Writer::InsAsString8(ww::bytes &rO, const OUString& rStr,
      rtl_TextEncoding eCodeSet)
1724{
  OString sTmp(OUStringToOString(rStr, eCodeSet));
  const char *pStart = sTmp.getStr();
  const char *pEnd = pStart + sTmp.getLength();

  rO.insert( rO.end(), pStart, pEnd );
1730}

1732void SwWW8Writer::WriteString16(SvStream& rStrm, const OUString& rStr,
  bool bAddZero)
1734{
  ww::bytes aBytes;
  SwWW8Writer::InsAsString16(aBytes, rStr);
  if (bAddZero)
      SwWW8Writer::InsUInt16(aBytes, 0);
  //vectors are guaranteed to have contiguous memory, so we can do
  //this while migrating away from WW8Bytes. Meyers Effective STL, item 16
  if (!aBytes.empty())
      rStrm.WriteBytes(aBytes.data(), aBytes.size());
1743}

1745void SwWW8Writer::WriteString_xstz(SvStream& rStrm, const OUString& rStr, bool bAddZero)
1746{
  ww::bytes aBytes;
  SwWW8Writer::InsUInt16(aBytes, rStr.getLength());
  SwWW8Writer::InsAsString16(aBytes, rStr);
  if (bAddZero)
      SwWW8Writer::InsUInt16(aBytes, 0);
  rStrm.WriteBytes(aBytes.data(), aBytes.size());
1753}

1755void SwWW8Writer::WriteString8(SvStream& rStrm, const OUString& rStr,
  bool bAddZero, rtl_TextEncoding eCodeSet)
1757{
  ww::bytes aBytes;
  SwWW8Writer::InsAsString8(aBytes, rStr, eCodeSet);
  if (bAddZero)
      aBytes.push_back(0);
  //vectors are guaranteed to have contiguous memory, so we can do
  ////this while migrating away from WW8Bytes. Meyers Effective STL, item 16
  if (!aBytes.empty())
      rStrm.WriteBytes(aBytes.data(), aBytes.size());
1766}

1768void WW8Export::WriteStringAsPara( const OUString& rText )
1769{
  if( !rText.isEmpty() )
      OutSwString(rText, 0, rText.getLength());
  WriteCR();              // CR thereafter

  ww::bytes aArr;
  SwWW8Writer::InsUInt16( aArr, 0/*nStyleId*/ );
  if( m_bOutTable )
  {                                               // Tab-Attr
      // sprmPFInTable
      SwWW8Writer::InsUInt16( aArr, NS_sprm::PFInTable::val );
      aArr.push_back( 1 );
  }

  sal_uInt64 nPos = Strm().Tell();
  m_pPapPlc->AppendFkpEntry( nPos, aArr.size(), aArr.data() );
  m_pChpPlc->AppendFkpEntry( nPos );
1786}

1788void MSWordExportBase::WriteSpecialText( sal_uLong nStart, sal_uLong nEnd, sal_uInt8 nTTyp )
1789{
  sal_uInt8 nOldTyp = m_nTextTyp;
  m_nTextTyp = nTTyp;
  auto const pOldPam = m_pCurPam;       //!! Simply shifting the PaM without restoring should do the job too
  sal_uLong nOldStart = m_nCurStart;
  sal_uLong nOldEnd = m_nCurEnd;
  SwPaM* pOldEnd = m_pOrigPam;
  bool bOldPageDescs = m_bOutPageDescs;
  m_bOutPageDescs = false;
  if ( nTTyp == TXT_FTN || nTTyp == TXT_EDN )
      m_bAddFootnoteTab = true;   // enable one aesthetic tab for this footnote

  SetCurPam(nStart, nEnd);

  // clear linked textboxes since old ones can't be linked to frames in this section
  m_aLinkedTextboxesHelper.clear();

  // tdf#106261 Reset table infos, otherwise the depth of the cells will be
  // incorrect, in case the header/footer had table(s) and we try to export
  // the same table second time.
  ww8::WW8TableInfo::Pointer_t pOldTableInfo = m_pTableInfo;
  m_pTableInfo = std::make_shared<ww8::WW8TableInfo>();

  WriteText();

  m_pTableInfo = pOldTableInfo;

  m_bOutPageDescs = bOldPageDescs;
  m_pCurPam = pOldPam; // delete Pam
  m_nCurStart = nOldStart;
  m_nCurEnd = nOldEnd;
  m_pOrigPam = pOldEnd;
  m_nTextTyp = nOldTyp;
1822}

1824void WW8Export::OutSwString(const OUString& rStr, sal_Int32 nStt,
  sal_Int32 const nLen)

1827{
  SAL_INFO( "sw.ww8.level2", "<OutSwString>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "<OutSwString>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1828" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<OutSwString>"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<OutSwString>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1828" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "<OutSwString>") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1828" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<OutSwString>"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<OutSwString>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1828" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

  if( nLen )
  {
      if( nStt || nLen != rStr.getLength() )
      {
          OUString sOut( rStr.copy( nStt, nLen ) );

          SAL_INFO( "sw.ww8.level2", sOut )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << sOut) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1836" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << sOut), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << sOut; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1836" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << sOut) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1836" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << sOut), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << sOut; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1836" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

          SwWW8Writer::WriteString16(Strm(), sOut, false);
      }
      else
      {
          SAL_INFO( "sw.ww8.level2", rStr )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << rStr) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1842" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << rStr), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << rStr; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1842" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << rStr) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1842" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << rStr), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << rStr; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1842" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

          SwWW8Writer::WriteString16(Strm(), rStr, false);
      }
  }

  SAL_INFO( "sw.ww8.level2", "</OutSwString>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "</OutSwString>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1848" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutSwString>"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</OutSwString>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1848" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "</OutSwString>") == 1) { ::sal_detail_log(
 (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1848" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutSwString>"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</OutSwString>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1848" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
1849}

1851void WW8Export::WriteCR(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
1852{
  if (pTableTextNodeInfoInner && pTableTextNodeInfoInner->getDepth() == 1 && pTableTextNodeInfoInner->isEndOfCell())
      WriteChar('\007');
  else
      WriteChar( '\015' );

  m_pPiece->SetParaBreak();
1859}

1861void WW8Export::WriteChar( sal_Unicode c )
1862{
  Strm().WriteUInt16( c );
1864}

1866void MSWordExportBase::SetCurPam(sal_uLong nStt, sal_uLong nEnd)
1867{
  m_nCurStart = nStt;
  m_nCurEnd = nEnd;
  m_pCurPam = Writer::NewUnoCursor( m_rDoc, nStt, nEnd );

  // Recognize tables in special cases
  if ( nStt != m_pCurPam->GetMark()->nNode.GetIndex() &&
       m_rDoc.GetNodes()[ nStt ]->IsTableNode() )
  {
      m_pCurPam->GetMark()->nNode = nStt;
  }

  m_pOrigPam = m_pCurPam.get(); // ???
  m_pCurPam->Exchange();
1881}

1883void MSWordExportBase::SaveData( sal_uLong nStt, sal_uLong nEnd )
1884{
  MSWordSaveData aData;

  // WW8Export only stuff - zeroed here not to issue warnings
  aData.pOOld = nullptr;

  // Common stuff
  aData.pOldPam = m_pCurPam;
  aData.pOldEnd = m_pOrigPam;
  aData.pOldFlyFormat = m_pParentFrame;
  aData.pOldPageDesc = m_pCurrentPageDesc;

  aData.pOldFlyOffset = m_pFlyOffset;
  aData.eOldAnchorType = m_eNewAnchorType;

  aData.bOldOutTable = m_bOutTable;
  aData.bOldFlyFrameAttrs = m_bOutFlyFrameAttrs;
  aData.bOldStartTOX = m_bStartTOX;
  aData.bOldInWriteTOX = m_bInWriteTOX;

  SetCurPam(nStt, nEnd);

  m_bOutTable = false;
  // Caution: bIsInTable should not be set here
  m_bOutFlyFrameAttrs = false;
  m_bStartTOX = false;
  m_bInWriteTOX = false;

  m_aSaveData.push( std::move(aData) );
1913}

1915void MSWordExportBase::RestoreData()
1916{
  MSWordSaveData &rData = m_aSaveData.top();

  m_pCurPam = rData.pOldPam;
  m_nCurStart = rData.nOldStart;
  m_nCurEnd = rData.nOldEnd;
  m_pOrigPam = rData.pOldEnd;

  m_bOutTable = rData.bOldOutTable;
  m_bOutFlyFrameAttrs = rData.bOldFlyFrameAttrs;
  m_bStartTOX = rData.bOldStartTOX;
  m_bInWriteTOX = rData.bOldInWriteTOX;

  m_pParentFrame = rData.pOldFlyFormat;
  m_pCurrentPageDesc = rData.pOldPageDesc;

  m_eNewAnchorType = rData.eOldAnchorType;
  m_pFlyOffset = rData.pOldFlyOffset;

  m_aSaveData.pop();
1936}

1938void WW8Export::SaveData( sal_uLong nStt, sal_uLong nEnd )
1939{
  MSWordExportBase::SaveData( nStt, nEnd );

  MSWordSaveData &rData = m_aSaveData.top();

  if ( !pO->empty() )
  {
      rData.pOOld = std::move(pO);
      pO.reset(new ww::bytes);
  }
  else
      rData.pOOld = nullptr; // reuse pO

  rData.bOldWriteAll = GetWriter().m_bWriteAll;
  GetWriter().m_bWriteAll = true;
1954}

1956void WW8Export::RestoreData()
1957{
  MSWordSaveData &rData = m_aSaveData.top();

  GetWriter().m_bWriteAll = rData.bOldWriteAll;

  OSL_ENSURE( pO->empty(), "pO is not empty in WW8Export::RestoreData()" )do { if (true && (!(pO->empty()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "1962" ": "), "%s", "pO is not empty in WW8Export::RestoreData()"
); } } while (false);
  if ( rData.pOOld )
  {
      pO = std::move(rData.pOOld);
  }

  MSWordExportBase::RestoreData();
1969}

1971void WW8AttributeOutput::TableInfoCell( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
1972{
  sal_uInt32 nDepth = pTableTextNodeInfoInner->getDepth();

  if ( nDepth <= 0 )
      return;

  /* Cell */
  m_rWW8Export.InsUInt16( NS_sprm::PFInTable::val );
  m_rWW8Export.pO->push_back( sal_uInt8(0x1) );
  m_rWW8Export.InsUInt16( NS_sprm::PItap::val );
  m_rWW8Export.InsUInt32( nDepth );

  if ( nDepth > 1 && pTableTextNodeInfoInner->isEndOfCell() )
  {
      m_rWW8Export.InsUInt16( NS_sprm::PFInnerTableCell::val );
      m_rWW8Export.pO->push_back( sal_uInt8(0x1) );
  }
1989}

1991void WW8AttributeOutput::TableInfoRow( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
1992{
  sal_uInt32 nDepth = pTableTextNodeInfoInner->getDepth();

  if ( nDepth <= 0 )
      return;

  /* Row */
  if ( !pTableTextNodeInfoInner->isEndOfLine() )
      return;

  m_rWW8Export.InsUInt16( NS_sprm::PFInTable::val );
  m_rWW8Export.pO->push_back( sal_uInt8(0x1) );

  if ( nDepth == 1 )
  {
      m_rWW8Export.InsUInt16( NS_sprm::PFTtp::val );
      m_rWW8Export.pO->push_back( sal_uInt8(0x1) );
  }

  m_rWW8Export.InsUInt16( NS_sprm::PItap::val );
  m_rWW8Export.InsUInt32( nDepth );

  if ( nDepth > 1 )
  {
      m_rWW8Export.InsUInt16( NS_sprm::PFInnerTableCell::val );
      m_rWW8Export.pO->push_back( sal_uInt8(0x1) );
      m_rWW8Export.InsUInt16( NS_sprm::PFInnerTtp::val );
      m_rWW8Export.pO->push_back( sal_uInt8(0x1) );
  }

  // Most of these are per-row definitions, not per-table.
  // WW8 has no explicit table start/end markup,
  // simply rows with the same table properties that are grouped together as a table.
  TableBidi( pTableTextNodeInfoInner );
  TableOrientation( pTableTextNodeInfoInner );
  TableSpacing( pTableTextNodeInfoInner );
  TableDefinition( pTableTextNodeInfoInner );     //per row definitions
  TableHeight( pTableTextNodeInfoInner );         //per row definitions
  TableBackgrounds( pTableTextNodeInfoInner );    //per row definitions
  // Since this isEndOfLine, cell margin defaults for each row come from last column.
  TableDefaultBorders( pTableTextNodeInfoInner ); //per row definitions
  TableCanSplit( pTableTextNodeInfoInner );       //per row definitions
  TableVerticalCell( pTableTextNodeInfoInner );   //per row definitions
  TableCellBorders( pTableTextNodeInfoInner );    //per row definitions
2036}

2038static sal_uInt16 lcl_TCFlags(SwDoc &rDoc, const SwTableBox * pBox, sal_Int32 nRowSpan)
2039{
  sal_uInt16 nFlags = 0;

  if (nRowSpan > 1)
      nFlags |= (3 << 5);
  else if (nRowSpan < 0)
      nFlags |= (1 << 5);

  if (pBox != nullptr)
  {
      const SwFrameFormat * pFormat = pBox->GetFrameFormat();
      switch (pFormat->GetVertOrient().GetVertOrient())
      {
          case text::VertOrientation::CENTER:
              nFlags |= (1 << 7);
              break;
          case text::VertOrientation::BOTTOM:
              nFlags |= (2 << 7);
              break;
          default:
              break;
      }
      const SwStartNode * pSttNd = pBox->GetSttNd();
      if(pSttNd)
      {
          SwNodeIndex aIdx( *pSttNd );
          const SwContentNode * pCNd = pSttNd->GetNodes().GoNext( &aIdx );
          if( pCNd && pCNd->IsTextNode())
          {
              SfxItemSet aCoreSet(rDoc.GetAttrPool(), svl::Items<RES_CHRATR_ROTATE, RES_CHRATR_ROTATE>{});
              static_cast<const SwTextNode*>(pCNd)->GetParaAttr(aCoreSet,
                  0, static_cast<const SwTextNode*>(pCNd)->GetText().getLength());
              const SfxPoolItem * pRotItem;
              if ( SfxItemState::SET == aCoreSet.GetItemState(RES_CHRATR_ROTATE, true, &pRotItem))
              {
                  const SvxCharRotateItem * pRotate = static_cast<const SvxCharRotateItem*>(pRotItem);
                  if(pRotate && pRotate->GetValue() == 900)
                  {
                      nFlags = nFlags | 0x0004 | 0x0008;
                  }
                  else if(pRotate && pRotate->GetValue() == 2700 )
                  {
                      nFlags = nFlags | 0x0004 | 0x0010;
                  }
              }
          }
      }
  }

  return nFlags;
2089}

2091void WW8AttributeOutput::TableVerticalCell( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2092{
  const SwTableBox * pTabBox = pTableTextNodeInfoInner->getTableBox();
  const SwTableLine * pTabLine = pTabBox->GetUpper();
  const SwTableBoxes & rTableBoxes = pTabLine->GetTabBoxes();

  sal_uInt8 nBoxes = rTableBoxes.size();
  for ( sal_uInt8 n = 0; n < nBoxes; n++ )
  {
      const SwTableBox * pTabBox1 = rTableBoxes[n];
      const SwFrameFormat * pFrameFormat = pTabBox1->GetFrameFormat();

      // Map from our SvxFrameDirection to WW8 TextFlow.
      sal_uInt16 nTextFlow = 0;
      switch (m_rWW8Export.TrueFrameDirection(*pFrameFormat))
      {
          case SvxFrameDirection::Vertical_RL_TB:
              nTextFlow = 5;
              break;
          case SvxFrameDirection::Vertical_LR_BT:
              nTextFlow = 3;
              break;
          default:
              break;
      }

      if (nTextFlow != 0)
      {
          m_rWW8Export.InsUInt16( NS_sprm::TTextFlow::val );
          m_rWW8Export.pO->push_back( n );                   //start range
          m_rWW8Export.pO->push_back( sal_uInt8(n + 1) );    //end range
          m_rWW8Export.InsUInt16(nTextFlow);
      }
  }
2125}

2127void WW8AttributeOutput::TableCanSplit( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2128{
  const SwTableBox * pTabBox = pTableTextNodeInfoInner->getTableBox();
  const SwTableLine * pTabLine = pTabBox->GetUpper();
  const SwFrameFormat * pLineFormat = pTabLine->GetFrameFormat();

  /*
   By default the row can be split in word, and now in writer we have a
   feature equivalent to this, Word stores 1 for fCantSplit if the row
   cannot be split, we set true if we can split it. An example is #i4569#
   */

  const SwFormatRowSplit& rSplittable = pLineFormat->GetRowSplit();
  sal_uInt8 nCantSplit = (!rSplittable.GetValue()) ? 1 : 0;
  m_rWW8Export.InsUInt16( NS_sprm::TFCantSplit::val );
  m_rWW8Export.pO->push_back( nCantSplit );
  m_rWW8Export.InsUInt16( NS_sprm::TFCantSplit90::val ); // also write fCantSplit90
  m_rWW8Export.pO->push_back( nCantSplit );
2145}

2147void WW8AttributeOutput::TableBidi( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2148{
  const SwTable * pTable = pTableTextNodeInfoInner->getTable();
  const SwFrameFormat * pFrameFormat = pTable->GetFrameFormat();

  if ( m_rWW8Export.TrueFrameDirection(*pFrameFormat) == SvxFrameDirection::Horizontal_RL_TB )
  {
      m_rWW8Export.InsUInt16( NS_sprm::TFBiDi::val );
      m_rWW8Export.InsUInt16( 1 );
  }
2157}

2159void WW8AttributeOutput::TableRowRedline( ww8::WW8TableNodeInfoInner::Pointer_t /*pTableTextNodeInfoInner*/ )
2160{
2161}

2163void WW8AttributeOutput::TableCellRedline( ww8::WW8TableNodeInfoInner::Pointer_t /*pTableTextNodeInfoInner*/ )
2164{
2165}

2167void WW8AttributeOutput::TableHeight( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2168{
  const SwTableBox * pTabBox = pTableTextNodeInfoInner->getTableBox();
  const SwTableLine * pTabLine = pTabBox->GetUpper();
  const SwFrameFormat * pLineFormat = pTabLine->GetFrameFormat();

  // output line height   sprmTDyaRowHeight
  long nHeight = 0;
  const SwFormatFrameSize& rLSz = pLineFormat->GetFrameSize();
  if ( SwFrameSize::Variable != rLSz.GetHeightSizeType() && rLSz.GetHeight() )
  {
      if ( SwFrameSize::Minimum == rLSz.GetHeightSizeType() )
          nHeight = rLSz.GetHeight();
      else
          nHeight = -rLSz.GetHeight();
  }

  if ( nHeight )
  {
      m_rWW8Export.InsUInt16( NS_sprm::TDyaRowHeight::val );
      m_rWW8Export.InsUInt16( static_cast<sal_uInt16>(nHeight) );
  }

2190}

2192void WW8AttributeOutput::TableOrientation( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2193{
  const SwTable * pTable = pTableTextNodeInfoInner->getTable();

  const SwFrameFormat *pFormat = pTable->GetFrameFormat();
  if ( !pFormat )
  {
      SAL_WARN( "sw.ww8", "FrameFormat is nil" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "FrameFormat is nil")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2199" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "FrameFormat is nil"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FrameFormat is nil"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2199" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "FrameFormat is nil") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2199" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "FrameFormat is nil"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FrameFormat is nil"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2199" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return;
  }

  const SwFormatHoriOrient &rHori = pFormat->GetHoriOrient();
  const SwFormatVertOrient &rVert = pFormat->GetVertOrient();

  if (
      !((text::RelOrientation::PRINT_AREA == rHori.GetRelationOrient() ||
       text::RelOrientation::FRAME == rHori.GetRelationOrient())
      &&
      (text::RelOrientation::PRINT_AREA == rVert.GetRelationOrient() ||
       text::RelOrientation::FRAME == rVert.GetRelationOrient()))
      )
      return;

  const bool bIsRTL = m_rWW8Export.TrueFrameDirection(*pFormat) == SvxFrameDirection::Horizontal_RL_TB;
  sal_Int16 eHOri = rHori.GetHoriOrient();
  switch (eHOri)
  {
      case text::HoriOrientation::CENTER:
          m_rWW8Export.InsUInt16( NS_sprm::TJc::val ); //logical orientation required for MSO
          m_rWW8Export.InsUInt16( 1 );
          m_rWW8Export.InsUInt16( NS_sprm::TJc90::val ); //physical orientation required for LO
          m_rWW8Export.InsUInt16( 1 );
          break;
      case text::HoriOrientation::RIGHT:
          m_rWW8Export.InsUInt16( NS_sprm::TJc90::val ); //required for LO
          m_rWW8Export.InsUInt16( 2 );
          if ( !bIsRTL )
          {
              m_rWW8Export.InsUInt16( NS_sprm::TJc::val ); //required for MSO
              m_rWW8Export.InsUInt16( 2 );
          }
          break;
      case text::HoriOrientation::LEFT:
          if ( bIsRTL )
          {
              m_rWW8Export.InsUInt16( NS_sprm::TJc::val ); //required for MSO
              m_rWW8Export.InsUInt16( 2 );
          }
          break;
      case text::HoriOrientation::LEFT_AND_WIDTH:
          // Width can only be specified for the LOGICAL left, so in RTL, that is always PHYSICAL right
          if ( bIsRTL )
          {
              m_rWW8Export.InsUInt16( NS_sprm::TJc90::val ); //required for LO
              m_rWW8Export.InsUInt16( 2 );
          }
          break;
      default:
          break;
  }
2252}

2254void WW8AttributeOutput::TableSpacing(ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner)
2255{
  const SwTable * pTable = pTableTextNodeInfoInner->getTable();
  const SwTableFormat* pTableFormat = pTable->GetFrameFormat();


  // Writing these SPRM's will make the table a floating one, so only write
  // them in case the table is already inside a frame.
  if (!(pTableFormat != nullptr && pTable->GetTableNode()->GetFlyFormat()))
      return;

  const SvxULSpaceItem & rUL = pTableFormat->GetULSpace();

  if (rUL.GetUpper() > 0)
  {
      sal_uInt8 const nPadding = 2;
      sal_uInt8 const nPcVert = 0;
      sal_uInt8 const nPcHorz = 0;

      sal_uInt8 const nTPc = (nPadding << 4) | (nPcVert << 2) | nPcHorz;

      m_rWW8Export.InsUInt16(NS_sprm::TPc::val);
      m_rWW8Export.pO->push_back( nTPc );

      m_rWW8Export.InsUInt16(NS_sprm::TDyaAbs::val);
      m_rWW8Export.InsUInt16(rUL.GetUpper());

      m_rWW8Export.InsUInt16(NS_sprm::TDyaFromText::val);
      m_rWW8Export.InsUInt16(rUL.GetUpper());
  }

  if (rUL.GetLower() > 0)
  {
      m_rWW8Export.InsUInt16(NS_sprm::TDyaFromTextBottom::val);
      m_rWW8Export.InsUInt16(rUL.GetLower());
  }
2290}

2292void WW8AttributeOutput::TableDefinition( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2293{
  const SwTable * pTable = pTableTextNodeInfoInner->getTable();

  if ( pTable->GetRowsToRepeat() > pTableTextNodeInfoInner->getRow() )
  {
      m_rWW8Export.InsUInt16( NS_sprm::TTableHeader::val );
      m_rWW8Export.pO->push_back( 1 );
  }

  ww8::TableBoxVectorPtr pTableBoxes =
      pTableTextNodeInfoInner->getTableBoxesOfRow();
  // number of cell written
  sal_uInt32 nBoxes = pTableBoxes->size();
  assert(nBoxes <= ww8::MAXTABLECELLS)(static_cast <bool> (nBoxes <= ww8::MAXTABLECELLS) ?
 void (0) : __assert_fail ("nBoxes <= ww8::MAXTABLECELLS",
 "/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
, 2306, __extension__ __PRETTY_FUNCTION__));

  // sprm header
  m_rWW8Export.InsUInt16( NS_sprm::TDefTable::val );
  sal_uInt16 nSprmSize = 2 + (nBoxes + 1) * 2 + nBoxes * 20;
  m_rWW8Export.InsUInt16( nSprmSize ); // length

  // number of boxes
  m_rWW8Export.pO->push_back( static_cast<sal_uInt8>(nBoxes) );

  /* cells */
  /*
   ALWAYS relative when text::HoriOrientation::NONE (nPageSize + ( nPageSize / 10 )) < nTableSz,
   in that case the cell width's and table width's are not real. The table
   width is maxed and cells relative, so we need the frame (generally page)
   width that the table is in to work out the true widths.
   */
  //const bool bNewTableModel = pTable->IsNewModel();
  const SwFrameFormat *pFormat = pTable->GetFrameFormat();
  if ( !pFormat )
  {
      SAL_WARN( "sw.ww8", "FrameFormat is nil" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "FrameFormat is nil")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2327" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "FrameFormat is nil"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FrameFormat is nil"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2327" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "FrameFormat is nil") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2327" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "FrameFormat is nil"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FrameFormat is nil"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2327" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return;
  }

  const SwFormatHoriOrient &rHori = pFormat->GetHoriOrient();
  const SwFormatVertOrient &rVert = pFormat->GetVertOrient();

  SwTwips nTableOffset = 0;

  if (
      (text::RelOrientation::PRINT_AREA == rHori.GetRelationOrient() ||
       text::RelOrientation::FRAME == rHori.GetRelationOrient())
      &&
      (text::RelOrientation::PRINT_AREA == rVert.GetRelationOrient() ||
       text::RelOrientation::FRAME == rVert.GetRelationOrient())
      )
  {
      sal_Int16 eHOri = rHori.GetHoriOrient();
      switch ( eHOri )
      {
          case text::HoriOrientation::CENTER:
          case text::HoriOrientation::RIGHT:
              break;

          default:
              nTableOffset = rHori.GetPos();
              const SvxLRSpaceItem& rLRSp = pFormat->GetLRSpace();
              nTableOffset += rLRSp.GetLeft();

              // convert offset to be measured from right margin in right-to-left tables
              if ( nTableOffset && m_rWW8Export.TrueFrameDirection(*pFormat) == SvxFrameDirection::Horizontal_RL_TB )
              {
                  SwTwips nLeftPageMargin, nRightPageMargin;
                  const SwTwips nPageSize = m_rWW8Export.CurrentPageWidth(nLeftPageMargin, nRightPageMargin);
                  const SwTwips nTableWidth = pFormat->GetFrameSize().GetWidth();
                  nTableOffset = nPageSize - nLeftPageMargin - nRightPageMargin - nTableWidth - nTableOffset;
              }
              break;
      }
  }

  m_rWW8Export.InsInt16( nTableOffset );

  ww8::GridColsPtr pGridCols = GetGridCols( pTableTextNodeInfoInner );
  for ( const auto nCol : *pGridCols )
   {
       m_rWW8Export.InsUInt16( static_cast<sal_uInt16>(nCol) + nTableOffset );
   }

   /* TCs */
  ww8::RowSpansPtr pRowSpans = pTableTextNodeInfoInner->getRowSpansOfRow();
  ww8::RowSpans::const_iterator aItRowSpans = pRowSpans->begin();

  for (const SwTableBox * pTabBox1 : *pTableBoxes)
  {
      sal_uInt16 npOCount = m_rWW8Export.pO->size();

      const SwFrameFormat * pBoxFormat = nullptr;
      if (pTabBox1 != nullptr)
          pBoxFormat = pTabBox1->GetFrameFormat();

      sal_uInt16 nFlags =
          lcl_TCFlags(m_rWW8Export.m_rDoc, pTabBox1, *aItRowSpans);
      m_rWW8Export.InsUInt16( nFlags );

      static sal_uInt8 aNullBytes[] = { 0x0, 0x0 };

      m_rWW8Export.pO->insert( m_rWW8Export.pO->end(), aNullBytes, aNullBytes+2 );   // dummy
      if (pBoxFormat != nullptr)
      {
          const SvxBoxItem & rBoxItem = pBoxFormat->GetBox();

          WW8Export::Out_SwFormatTableBox( *m_rWW8Export.pO, &rBoxItem ); // 8/16 Byte
      }
      else
          WW8Export::Out_SwFormatTableBox( *m_rWW8Export.pO, nullptr); // 8/16 Byte

      SAL_INFO( "sw.ww8.level2", "<tclength>" << ( m_rWW8Export.pO->size() - npOCount ) << "</tclength>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "<tclength>" <<
 ( m_rWW8Export.pO->size() - npOCount ) << "</tclength>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2404" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<tclength>" << ( m_rWW8Export
.pO->size() - npOCount ) << "</tclength>"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "<tclength>" << ( m_rWW8Export.pO->size
() - npOCount ) << "</tclength>"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2404" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "<tclength>" << ( m_rWW8Export.pO->
size() - npOCount ) << "</tclength>") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2404" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<tclength>" << ( m_rWW8Export
.pO->size() - npOCount ) << "</tclength>"), 0)
; } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "<tclength>" << ( m_rWW8Export.pO->size
() - npOCount ) << "</tclength>"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2404" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      ++aItRowSpans;
  }

  int nWidthPercent = pFormat->GetFrameSize().GetWidthPercent();
  // Width is in fiftieths of a percent. For sprmTTableWidth, must be non-negative and 600% max
  if ( nWidthPercent > 0 && nWidthPercent <= 600 )
  {
      m_rWW8Export.InsUInt16( NS_sprm::TTableWidth::val );
      m_rWW8Export.pO->push_back( sal_uInt8/*ftsPercent*/ (2) );
      m_rWW8Export.InsUInt16( static_cast<sal_uInt16>(nWidthPercent) * 50 );
  }
2416}

2418ww8::GridColsPtr AttributeOutputBase::GetGridCols( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner )
2419{
  return pTableTextNodeInfoInner->getGridColsOfRow(*this);
2421}

2423ww8::WidthsPtr AttributeOutputBase::GetColumnWidths( ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner )
2424{
  // Get the column widths based on ALL the rows, not just the current row
  return pTableTextNodeInfoInner->getGridColsOfRow(*this, true);
2427}

2429void AttributeOutputBase::GetTablePageSize( ww8::WW8TableNodeInfoInner const * pTableTextNodeInfoInner, long& rPageSize, bool& rRelBoxSize )
2430{
  long nPageSize = 0;

  const SwNode *pTextNd = pTableTextNodeInfoInner->getNode( );
  const SwTable *pTable = pTableTextNodeInfoInner->getTable( );

  const SwFrameFormat *pFormat = pTable->GetFrameFormat();
  if ( !pFormat )
  {
      SAL_WARN( "sw.ww8", "FrameFormat is nil" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "FrameFormat is nil")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2439" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "FrameFormat is nil"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FrameFormat is nil"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2439" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "FrameFormat is nil") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2439" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "FrameFormat is nil"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "FrameFormat is nil"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2439" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return;
  }

  const SwFormatFrameSize &rSize = pFormat->GetFrameSize();
  int nWidthPercent = rSize.GetWidthPercent();
  bool bManualAligned = pFormat->GetHoriOrient().GetHoriOrient() == text::HoriOrientation::NONE;
  if ( (pFormat->GetHoriOrient().GetHoriOrient() == text::HoriOrientation::FULL) || bManualAligned )
      nWidthPercent = 100;
  bool bRelBoxSize = nWidthPercent != 0;
  unsigned long nTableSz = static_cast<unsigned long>(rSize.GetWidth());
  if (nTableSz > USHRT_MAX(32767 *2 +1)/2 && !bRelBoxSize)
  {
      OSL_ENSURE(bRelBoxSize, "huge table width but not relative, suspicious")do { if (true && (!(bRelBoxSize))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2452" ": "), "%s", "huge table width but not relative, suspicious"
); } } while (false);
      bRelBoxSize = true;
  }

  if ( bRelBoxSize )
  {
      Point aPt;
      SwRect aRect( pFormat->FindLayoutRect( false, &aPt ) );
      if ( aRect.IsEmpty() )
      {
          // Then fetch the page width without margins!
          const SwFrameFormat* pParentFormat =
              GetExport().m_pParentFrame ?
              &(GetExport().m_pParentFrame->GetFrameFormat()) :
                  GetExport().m_rDoc.GetPageDesc(0).GetPageFormatOfNode(*pTextNd, false);
          aRect = pParentFormat->FindLayoutRect(true);
          nPageSize = aRect.Width();
          if ( 0 == nPageSize )
          {
              const SvxLRSpaceItem& rLR = pParentFormat->GetLRSpace();
              nPageSize = pParentFormat->GetFrameSize().GetWidth() - rLR.GetLeft()
              - rLR.GetRight();
          }
      }
      else
      {
          nPageSize = aRect.Width();
          if ( bManualAligned )
          {
              // #i37571# For manually aligned tables
              const SvxLRSpaceItem &rLR = pFormat->GetLRSpace();
              nPageSize -= (rLR.GetLeft() + rLR.GetRight());
          }

      }

      if ( nWidthPercent )
      {
          nPageSize *= nWidthPercent;
          nPageSize /= 100;
      }
      else
          SAL_WARN( "sw.ww8", "nWidthPercent is zero" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "nWidthPercent is zero"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2494" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "nWidthPercent is zero"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "nWidthPercent is zero"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2494" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "nWidthPercent is zero") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2494" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "nWidthPercent is zero"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "nWidthPercent is zero"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2494" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
  else
  {
      // As the table width is not relative, the TablePageSize equals its width
      nPageSize = nTableSz;
  }

  rPageSize = nPageSize;
  rRelBoxSize = bRelBoxSize;
2504}

2506void WW8AttributeOutput::TableDefaultBorders( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2507{
  // This function name is misleading because it is not a table default, but a row default,
  // and it also only sets default cell margins (aka border padding).
  // The specs suggest there is no way to define default border lines/colors.
  const SwTableBox * pTabBox = pTableTextNodeInfoInner->getTableBox();
  const SwFrameFormat * pFrameFormat = pTabBox->GetFrameFormat();

  static const SvxBoxItemLine aBorders[] =
  {
      SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
      SvxBoxItemLine::BOTTOM, SvxBoxItemLine::RIGHT
  };

  // Set row default cell margins using this last cell in the row
  for ( int i = 0; i < 4; ++i )
  {
      SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::TCellPaddingDefault::val );
      m_rWW8Export.pO->push_back( sal_uInt8(6) );
      m_rWW8Export.pO->push_back( sal_uInt8(0) );
      m_rWW8Export.pO->push_back( sal_uInt8(1) );
      m_rWW8Export.pO->push_back( sal_uInt8(1 << i) );
      m_rWW8Export.pO->push_back( sal_uInt8(3) );

      SwWW8Writer::InsUInt16( *m_rWW8Export.pO,
              pFrameFormat->GetBox().GetDistance( aBorders[i] ) );
  }
2533}

2535void WW8AttributeOutput::TableCellBorders(
  ww8::WW8TableNodeInfoInner::Pointer_t const & pTableTextNodeInfoInner )
2537{
  const SwTableBox * pTabBox = pTableTextNodeInfoInner->getTableBox();
  const SwTableLine * pTabLine = pTabBox->GetUpper();
  const SwTableBoxes & rTabBoxes = pTabLine->GetTabBoxes();
  sal_uInt8 nBoxes = std::min<size_t>(rTabBoxes.size(), 255);
  const SvxBoxItem * pLastBox = nullptr;
  sal_uInt8 nSeqStart = 0; // start of sequence of cells with same borders

  static const SvxBoxItemLine aBorders[] =
  {
      SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
      SvxBoxItemLine::BOTTOM, SvxBoxItemLine::RIGHT
  };

  sal_uInt16 nDefaultMargin[4] = {31681, 31681, 31681, 31681};  // outside of documented valid range
  // last column in each row defines the row default in TableRowDefaultBorders()
  if ( nBoxes && rTabBoxes.size() == nBoxes )
  {
      const SvxBoxItem& rBox = rTabBoxes[ nBoxes-1 ]->GetFrameFormat()->GetBox();
      for ( int i = 0; i < 4; ++i )
          nDefaultMargin[i] = rBox.GetDistance( aBorders[i] );
  }

  // Detect sequences of cells which have the same borders, and output
  // a border description for each such cell range.
  for ( unsigned n = 0; n <= nBoxes; ++n )
  {
      const SvxBoxItem * pBox = (n == nBoxes) ? nullptr :
          &rTabBoxes[n]->GetFrameFormat()->GetBox();
      if( !pLastBox )
          pLastBox = pBox;
      else if( !pBox || *pLastBox != *pBox )
      {
          // This cell has different borders than the previous cell,
          // so output the borders for the preceding cell range.
          m_rWW8Export.Out_CellRangeBorders(pLastBox, nSeqStart, n);

          // The last column is used as the row default for margins, so we can ignore these matching ones
          if ( n == nBoxes )
              break;

          // Output cell margins.
          // One CSSA can define up to all four margins if they are the same size value.
          sal_uInt16 nMargin[4];
          sal_uInt8 nSideBits[4] = {0, 0, 0, 0}; // 0001:top, 0010:left, 0100:bottom, 1000:right
          for ( int i = 0; i < 4; ++i )  // sides: top, left, bottom, right
          {
              nMargin[i] = std::min(sal_uInt16(31680), pLastBox->GetDistance( aBorders[i] ));
              if ( nMargin[i] == nDefaultMargin[i] )
                  continue;

              // join a previous side's definition if it shares the same value
              for ( int p = 0; p < 4; ++p )
              {
                  if ( nMargin[i] == nMargin[p] )
                  {
                      nSideBits[p] |= 1 << i;
                      break;
                  }
              }
          }

          // write out the cell margins definitions that were used
          for ( int i = 0; i < 4; ++i )
          {
              if ( nSideBits[i] )
              {
                  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::TCellPadding::val );
                  m_rWW8Export.pO->push_back( sal_uInt8(6) );            // 6 bytes
                  m_rWW8Export.pO->push_back( sal_uInt8(nSeqStart) );    // first cell: apply margin
                  m_rWW8Export.pO->push_back( sal_uInt8(n) );            // end cell: do not apply margin
                  m_rWW8Export.pO->push_back( sal_uInt8(nSideBits[i]) );
                  m_rWW8Export.pO->push_back( sal_uInt8(3) );            // FtsDxa: size in twips
                  SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nMargin[i] );
              }
          }

          nSeqStart = n;
          pLastBox = pBox;
      }
  }
2618}

2620void WW8AttributeOutput::TableBackgrounds( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )
2621{
  const SwTable * pTab = pTableTextNodeInfoInner->getTable();
  const SwTableBox * pTabBox = pTableTextNodeInfoInner->getTableBox();
  const SwTableLine * pTabLine = pTabBox->GetUpper();
  const SwTableBoxes & rTabBoxes = pTabLine->GetTabBoxes();

  sal_uInt8 nBoxes = rTabBoxes.size();
  m_rWW8Export.InsUInt16( NS_sprm::TDefTableShd80::val );
  m_rWW8Export.pO->push_back( static_cast<sal_uInt8>(nBoxes * 2) );  // Len

  Color aRowColor = COL_AUTO;
  const SvxBrushItem *pTableColorProp = pTab->GetFrameFormat()->GetAttrSet().GetItem<SvxBrushItem>(RES_BACKGROUND);
  if ( pTableColorProp )
      aRowColor = pTableColorProp->GetColor();

  const SvxBrushItem *pRowColorProp = pTabLine->GetFrameFormat()->GetAttrSet().GetItem<SvxBrushItem>(RES_BACKGROUND);
  if ( pRowColorProp && pRowColorProp->GetColor() != COL_AUTO )
      aRowColor = pRowColorProp->GetColor();

  for ( sal_uInt8 n = 0; n < nBoxes; n++ )
  {
      const SwTableBox * pBox1 = rTabBoxes[n];
      const SwFrameFormat * pFrameFormat = pBox1->GetFrameFormat();
      Color aColor = aRowColor;

      const SvxBrushItem *pCellColorProp = pFrameFormat->GetAttrSet().GetItem<SvxBrushItem>(RES_BACKGROUND);
      if ( pCellColorProp && pCellColorProp->GetColor() != COL_AUTO )
          aColor = pCellColorProp->GetColor();

      WW8_SHD aShd;
      WW8Export::TransBrush( aColor, aShd );
      m_rWW8Export.InsUInt16( aShd.GetValue() );
  }

2655/*sprmTDefTableShdRaw:
* A DefTableShdOperand value that specifies the ... shading for cells 1 up to 22 in the row,
* ... Cells 23 to 44 are shaded by sprmTDefTableShdRaw2nd,
* and cells 45 to 63 are shaded by sprmTDefTableShdRaw3rd.
*/
  sal_uInt32 const aSprmIds[] { NS_sprm::TDefTableShd::val,
                                NS_sprm::TDefTableShdRaw::val,
                                NS_sprm::TDefTableShdRaw::val,
                                NS_sprm::TDefTableShd2nd::val,
                                NS_sprm::TDefTableShdRaw2nd::val,
                                NS_sprm::TDefTableShd3rd::val,
                                NS_sprm::TDefTableShdRaw3rd::val };
  for (sal_uInt32 m : aSprmIds)
  {
      sal_uInt8 nStart = 0;
      sal_uInt8 nStop = rTabBoxes.size();
      switch ( m )
      {
          case NS_sprm::TDefTableShd::val:
          case NS_sprm::TDefTableShdRaw::val:
              if ( nStop > 21 )
                  nStop = 22;
              break;
          case NS_sprm::TDefTableShd2nd::val:
          case NS_sprm::TDefTableShdRaw2nd::val:
              nStart = 22;
              if ( nStop > 43 )
                  nStop = 44;
              break;
          case NS_sprm::TDefTableShd3rd::val:
          case NS_sprm::TDefTableShdRaw3rd::val:
              nStart = 44;
              if ( nStop > 62 )
                  nStop = 63;
              break;
      }
      if ( nStart >= nStop )
          break;

      m_rWW8Export.InsUInt16( m );
      m_rWW8Export.pO->push_back( static_cast<sal_uInt8>((nStop-nStart) * 10) );

      for ( sal_uInt8 n = nStart; n < nStop; n++ )
      {
          const SwTableBox * pBox1 = rTabBoxes[n];
          const SwFrameFormat * pFrameFormat = pBox1->GetFrameFormat();
          Color aColor = aRowColor;

          const SvxBrushItem *pCellColorProp = pFrameFormat->GetAttrSet().GetItem<SvxBrushItem>(RES_BACKGROUND);
          if ( pCellColorProp && pCellColorProp->GetColor() != COL_AUTO )
              aColor = pCellColorProp->GetColor();

          WW8SHDLong aSHD;
          aSHD.setCvFore( 0xFF000000 );

          if ( aColor == COL_AUTO )
              aSHD.setCvBack( 0xFF000000 );
          else
              aSHD.setCvBack( wwUtility::RGBToBGR( aColor ) );

          aSHD.Write( m_rWW8Export );
      }
  }
2718}

2720void WW8Export::SectionBreaksAndFrames( const SwTextNode& rNode )
2721{
  // output page/section breaks
  OutputSectionBreaks( rNode.GetpSwAttrSet(), rNode );
2724}

2726namespace {

2728class TrackContentToExport
2729{
2730private:
  SwPaM *m_pCurPam;
  sal_uLong m_nStart, m_nEnd;
2733public:
  TrackContentToExport(SwPaM *pCurPam, sal_uLong nCurStart, sal_uLong nCurEnd)
      : m_pCurPam(pCurPam)
      , m_nStart(nCurStart)
      , m_nEnd(nCurEnd)
  {
  }

  bool contentRemainsToExport(ww8::WW8TableInfo *pTableInfo)
  {
      bool bSimpleContentRemains = m_pCurPam->GetPoint()->nNode < m_pCurPam->GetMark()->nNode ||
          (m_pCurPam->GetPoint()->nNode == m_pCurPam->GetMark()->nNode &&
            m_pCurPam->GetPoint()->nContent.GetIndex() <= m_pCurPam->GetMark()->nContent.GetIndex());
      if (bSimpleContentRemains)
          return true;

      if (!pTableInfo)
          return false;

      //An old-school table where one cell may points back to a previous node as the next cell
      //so if this node is the last node in the range, we may need to jump back to a previously
      //skipped cell to output it in a sane sequence. See ooo47778-3.sxw for one of these
      //horrors. So if we are at the end of the selection, but this end point is a table
      //cell whose next cell is in the selection allow jumping back to it
      const SwNode* pCurrentNode = &m_pCurPam->GetPoint()->nNode.GetNode();
      const SwNode* pNextNode = pTableInfo->getNextNode(pCurrentNode);

      if (pNextNode && pCurrentNode != pNextNode)
      {
          return pNextNode->GetIndex() >= m_nStart &&
                 pNextNode->GetIndex() < m_nEnd;
      }

      return false;
  }
2768};

2770}

2772void MSWordExportBase::WriteText()
2773{
  TrackContentToExport aContentTracking(m_pCurPam.get(), m_nCurStart, m_nCurEnd);
  while (aContentTracking.contentRemainsToExport(m_pTableInfo.get()))
  {
      SwNode& rNd = m_pCurPam->GetNode();

      // no section breaks exported for Endnotes
      if ( rNd.IsTextNode() && m_nTextTyp != TXT_EDN && m_nTextTyp != TXT_FTN )
      {
          SwSoftPageBreakList breakList;
          // if paragraph need to be split than handle section break somewhere
          // else.
          if( !NeedTextNodeSplit( *rNd.GetTextNode(), breakList) )
              SectionBreaksAndFrames( *rNd.GetTextNode() );
      }


      // output the various types of nodes
      if ( rNd.IsContentNode() )
      {
          SwContentNode* pCNd = static_cast<SwContentNode*>(&rNd);

          const SwPageDesc* pTemp = rNd.FindPageDesc();
          if ( pTemp )
              m_pCurrentPageDesc = pTemp;

          m_pCurPam->GetPoint()->nContent.Assign( pCNd, 0 );
          OutputContentNode( *pCNd );
      }
      else if ( rNd.IsTableNode() )
      {
          m_pTableInfo->processSwTable( &rNd.GetTableNode()->GetTable() );
      }
      else if ( rNd.IsSectionNode() && TXT_MAINTEXT == m_nTextTyp )
          OutputSectionNode( *rNd.GetSectionNode() );
      else if ( TXT_MAINTEXT == m_nTextTyp && rNd.IsEndNode() &&
                rNd.StartOfSectionNode()->IsSectionNode() )
      {
          const SwSection& rSect = rNd.StartOfSectionNode()->GetSectionNode()
                                      ->GetSection();
          if ( m_bStartTOX && SectionType::ToxContent == rSect.GetType() )
              m_bStartTOX = false;

          SwNodeIndex aIdx( rNd, 1 );
          if ( aIdx.GetNode().IsEndNode() && aIdx.GetNode().StartOfSectionNode()->IsSectionNode() )
              ;
          else if ( aIdx.GetNode().IsSectionNode() )
              ;
          else if ( !IsInTable() )    //No sections in table
          {
              //#120140# Do not need to insert a page/section break after a section end. Check this case first
              bool bNeedExportBreakHere = true;
              if ( rSect.GetType() == SectionType::ToxContent || rSect.GetType() == SectionType::ToxHeader )
                  bNeedExportBreakHere = false;
              else if ( aIdx.GetNode().IsTextNode() )
              {
                  SwTextNode *pTempNext = aIdx.GetNode().GetTextNode();
                  if ( pTempNext )
                  {
                      const SfxPoolItem * pTempItem = nullptr;
                      if (pTempNext->GetpSwAttrSet() && SfxItemState::SET == pTempNext->GetpSwAttrSet()->GetItemState(RES_PAGEDESC, false, &pTempItem)
                          && pTempItem && static_cast<const SwFormatPageDesc*>(pTempItem)->GetRegisteredIn())
                      {
                          //Next node has a new page style which means this node is a section end. Do not insert another page/section break here
                          bNeedExportBreakHere = false;
                      }
                  }
              }
              else
              {
                  /* Do not export Section Break in case DOCX containing MultiColumn and
                   * aIdx.GetNode().IsTextNode() is False i.e. Text node is NULL.
                   */
                  const SwFrameFormat* pPgFormat = rSect.GetFormat();
                  const SwFormatCol& rCol = pPgFormat->GetCol();
                  sal_uInt16 nColumnCount = rCol.GetNumCols();
                  const SwFormatNoBalancedColumns& rNoBalanced = pPgFormat->GetBalancedColumns();
                  // Prevent the additional section break only for non-balanced columns.
                  if (nColumnCount > 1 && rNoBalanced.GetValue())
                  {
                      bNeedExportBreakHere = false;
                  }
                  // No need to create a "fake" section if this is the end of the document,
                  // except to emulate balanced columns.
                  else if ( nColumnCount < 2 && aIdx == m_rDoc.GetNodes().GetEndOfContent() )
                      bNeedExportBreakHere = false;
              }

              if (bNeedExportBreakHere)  //#120140# End of check
              {
                  ReplaceCr( char(0xc) ); // indicator for Page/Section-Break

                  const SwSectionFormat* pParentFormat = rSect.GetFormat()->GetParent();
                  if ( !pParentFormat )
                      pParentFormat = reinterpret_cast<SwSectionFormat*>(sal_IntPtr(-1));

                  sal_uLong nRstLnNum;
                  if ( aIdx.GetNode().IsContentNode() )
                      nRstLnNum = static_cast<SwContentNode&>(aIdx.GetNode()).GetSwAttrSet().
                                              GetLineNumber().GetStartValue();
                  else
                      nRstLnNum = 0;

                  AppendSection( m_pCurrentPageDesc, pParentFormat, nRstLnNum );
              }
              else
              {
                  OutputEndNode( *rNd.GetEndNode() );
              }
          }
      }
      else if ( rNd.IsStartNode() )
      {
          OutputStartNode( *rNd.GetStartNode() );
      }
      else if ( rNd.IsEndNode() )
      {
          OutputEndNode( *rNd.GetEndNode() );
      }

      if ( &rNd == &rNd.GetNodes().GetEndOfContent() )
          break;

      const SwNode * pCurrentNode = &m_pCurPam->GetPoint()->nNode.GetNode();
      const SwNode * pNextNode = m_pTableInfo->getNextNode(pCurrentNode);

      if (pCurrentNode == pNextNode)
      {
          SAL_WARN("sw.ww8", "loop in TableInfo")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "loop in TableInfo") ==
 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2901" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "loop in TableInfo"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "loop in TableInfo"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2901" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "loop in TableInfo") == 1) { ::sal_detail_log( (::
SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2901" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "loop in TableInfo"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "loop in TableInfo"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2901" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
          pNextNode = nullptr;
      }

      if (pNextNode != nullptr)
          m_pCurPam->GetPoint()->nNode.Assign(*pNextNode);
      else
          ++m_pCurPam->GetPoint()->nNode;

      sal_uLong nPos = m_pCurPam->GetPoint()->nNode.GetIndex();
      ::SetProgressState( nPos, m_pCurPam->GetDoc().GetDocShell() );
  }

  SAL_INFO( "sw.ww8.level2", "</WriteText>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "</WriteText>")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2914" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</WriteText>"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</WriteText>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2914" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "</WriteText>") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2914" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</WriteText>"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</WriteText>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2914" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
2915}

2917void WW8Export::WriteMainText()
2918{
  SAL_INFO( "sw.ww8.level2", "<WriteMainText>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "<WriteMainText>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2919" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<WriteMainText>"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<WriteMainText>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2919" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "<WriteMainText>") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2919" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<WriteMainText>"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<WriteMainText>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2919" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

  pFib->m_fcMin = Strm().Tell();

  m_pCurPam->GetPoint()->nNode = m_rDoc.GetNodes().GetEndOfContent().StartOfSectionNode()->GetIndex();

  WriteText();

  if( 0 == Strm().Tell() - pFib->m_fcMin )  // no text ?
      WriteCR();                  // then CR at the end ( otherwise WW will complain )

  pFib->m_ccpText = Fc2Cp( Strm().Tell() );
  m_pFieldMain->Finish( pFib->m_ccpText, 0 );

                  // ccpText includes Footnote and KF-text
                  // therefore pFib->ccpText may get updated as well
  // save the StyleId of the last paragraph. Because WW97 take the style
  // from the last CR, that will be written after footer/Header/footnotes/
  // annotation etc.
  const SwTextNode* pLastNd = m_pCurPam->GetMark()->nNode.GetNode().GetTextNode();
  if( pLastNd )
      m_nLastFormatId = GetId( static_cast<SwTextFormatColl&>(pLastNd->GetAnyFormatColl()) );

  SAL_INFO( "sw.ww8.level2", "</WriteMainText>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8.level2")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break
; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "</WriteMainText>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2942" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</WriteMainText>"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</WriteMainText>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2942" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "</WriteMainText>") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2942" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</WriteMainText>"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</WriteMainText>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8.level2"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "2942" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
2943}

2945bool MSWordExportBase::IsInTable() const
2946{
  bool bResult = false;

  if (m_pCurPam != nullptr)
  {
      SwNode& rNode = m_pCurPam->GetNode();

      if (m_pTableInfo)
      {
          ww8::WW8TableNodeInfo::Pointer_t pTableNodeInfo = m_pTableInfo->getTableNodeInfo(&rNode);

          if (pTableNodeInfo && pTableNodeInfo->getDepth() > 0)
          {
              bResult = true;
          }
      }
  }

  return bResult;
2965}

2967typedef ww8::WW8Sttb< ww8::WW8Struct >  WW8SttbAssoc;

2969void WW8Export::WriteFkpPlcUsw()
2970{
  // Graphics in the data stream
  m_pGrf->Write();                          // Graphics

  // output into WordDocument stream
  m_pChpPlc->WriteFkps();                   // Fkp.Chpx
  m_pPapPlc->WriteFkps();                   // Fkp.Papx
  pSepx->WriteSepx( Strm() );             // Sepx

  // output into Table stream
  m_pStyles->OutputStylesTable();           // for WW8 StyleTab
  pFootnote->WritePlc( *this );                // Footnote-Ref & Text Plc
  pEdn->WritePlc( *this );                // Endnote-Ref & Text Plc
  m_pTextBxs->WritePlc( *this );             // Textbox Text Plc
  m_pHFTextBxs->WritePlc( *this );           // Head/Foot-Textbox Text Plc
  m_pAtn->WritePlc( *this );                // Annotation-Ref & Text Plc

  pSepx->WritePlcSed( *this );            // Slcx.PlcSed
  pSepx->WritePlcHdd( *this );            // Slcx.PlcHdd

  m_pChpPlc->WritePlc();                    // Plcx.Chpx
  m_pPapPlc->WritePlc();                    // Plcx.Papx

  if( m_pRedlAuthors )
      m_pRedlAuthors->Write( GetWriter() );       // sttbfRMark (RedlineAuthors)
  m_pFieldMain->Write( *this );               // Fields ( Main Text )
  m_pFieldHdFt->Write( *this );               // Fields ( Header/Footer )
  m_pFieldFootnote->Write( *this );                // Fields ( FootNotes )
  m_pFieldEdn->Write( *this );                // Fields ( EndNotes )
  m_pFieldAtn->Write( *this );                // Fields ( Annotations )
  m_pFieldTextBxs->Write( *this );             // Fields ( Textboxes )
  m_pFieldHFTextBxs->Write( *this );           // Fields ( Head/Foot-Textboxes )

  if (m_pEscher || m_rDoc.ContainsMSVBasic())
  {
      /*
       Every time MS 2000 creates an escher stream there is always
       an ObjectPool dir (even if empty). It turns out that if a copy of
       MS 2000 is used to open a document that contains escher graphics
       exported from StarOffice without this empty dir then *if* that
       copy of MS Office has never been used to open a MSOffice document
       that has escher graphics (and an ObjectPool dir of course) and
       that copy of office has not been used to draw escher graphics then
       our exported graphics do not appear. Once you do open a ms
       document with escher graphics or draw an escher graphic with that
       copy of word, then all documents from staroffice that contain
       escher work from then on. Tricky to track down, some sort of late
       binding trickery in MS where solely for first time initialization
       the existence of an ObjectPool dir is necessary for triggering
       some magic.
      */
      // avoid memory leak #i120098#, the unnamed obj will be released in destructor.
      xEscherStg = GetWriter().GetStorage().OpenSotStorage(SL::aObjectPool);
  }

  // dggInfo - escher stream
  WriteEscher();

  m_pSdrObjs->WritePlc( *this );
  m_pHFSdrObjs->WritePlc( *this );
  // spamom - office drawing table
  // spahdr - header office drawing table

  m_pBkmks->Write( *this );                 // Bookmarks - sttbfBkmk/
                                          // plcfBkmkf/plcfBkmkl
  m_pFactoids->Write(*this);

  WriteNumbering();

  RestoreMacroCmds();

  m_pMagicTable->Write( *this );

  m_pPiece->WritePc( *this );               // Piece-Table
  m_aFontHelper.WriteFontTable(pTableStrm, *pFib); // FFNs

  //Convert OOo asian typography into MS typography structure
  ExportDopTypography(pDop->doptypography);

  WriteDop( *this );                      // Document-Properties

  // Write SttbfAssoc
  WW8SttbAssoc * pSttbfAssoc = dynamic_cast<WW8SttbAssoc *>
      (m_rDoc.getIDocumentExternalData().getExternalData(::sw::tExternalDataType::STTBF_ASSOC).get());

  if ( pSttbfAssoc )                      // #i106057#
  {
      std::vector<OUString> aStrings(pSttbfAssoc->getStrings());
      WriteAsStringTable(aStrings, pFib->m_fcSttbfAssoc,
                         pFib->m_lcbSttbfAssoc);
  }

  Strm().Seek( 0 );

  // Reclaim stored FIB data from document.
  ::ww8::WW8FibData * pFibData = dynamic_cast<ww8::WW8FibData *>
        (m_rDoc.getIDocumentExternalData().getExternalData(::sw::tExternalDataType::FIB).get());

  if ( pFibData )
  {
  pFib->m_fReadOnlyRecommended =
      pFibData->getReadOnlyRecommended();
  pFib->m_fWriteReservation =
      pFibData->getWriteReservation();
  }

  pFib->Write( Strm() );  // FIB
3077}

3079void WW8Export::StoreDoc1()
3080{
  bool bNeedsFinalPara = false;
  // Start of Text ( overwrite )
  SwWW8Writer::FillUntil( Strm(), pFib->m_fcMin );

  WriteMainText();                    // main text
  sal_uInt8 nSprmsLen;
  sal_uInt8 *pLastSprms = m_pPapPlc->CopyLastSprms(nSprmsLen);

  bNeedsFinalPara |= pFootnote->WriteText( *this );         // Footnote-Text
  bNeedsFinalPara |= pSepx->WriteKFText( *this );          // K/F-Text
  bNeedsFinalPara |= m_pAtn->WriteText( *this );         // Annotation-Text
  bNeedsFinalPara |= pEdn->WriteText( *this );         // EndNote-Text

  // create the escher streams
  CreateEscher();

  bNeedsFinalPara |= m_pTextBxs->WriteText( *this );  //Textbox Text Plc
  bNeedsFinalPara |= m_pHFTextBxs->WriteText( *this );//Head/Foot-Textbox Text Plc

  if (bNeedsFinalPara)
  {
      WriteCR();
      m_pPapPlc->AppendFkpEntry(Strm().Tell(), nSprmsLen, pLastSprms);
  }
  delete[] pLastSprms;

  pSepx->Finish( Fc2Cp( Strm().Tell() ));// Text + Footnote + HdFt as section end
  m_pMagicTable->Finish( Fc2Cp( Strm().Tell() ),0);

  pFib->m_fcMac = Strm().Tell();        // End of all texts

  WriteFkpPlcUsw();                   // FKP, PLC, ...
3113}

3115void MSWordExportBase::AddLinkTarget(const OUString& rURL)
3116{
  if( rURL.isEmpty() || rURL[0] != '#' )
      return;

  OUString aURL( BookmarkToWriter( rURL.copy( 1 ) ) );
  sal_Int32 nPos = aURL.lastIndexOf( cMarkSeparator );

  if( nPos < 2 )
      return;

  OUString sCmp = aURL.copy(nPos+1).replaceAll(" ", "");
  if( sCmp.isEmpty() )
      return;

  sCmp = sCmp.toAsciiLowerCase();
  sal_uLong nIdx = 0;
  bool noBookmark = false;

  if( sCmp == "outline" )
  {
      SwPosition aPos(*m_pCurPam->GetPoint());
      OUString aName(BookmarkToWriter(aURL.copy(0, nPos)));
      // If we can find the outline this bookmark refers to
      // save the name of the bookmark and the
      // node index number of where it points to
      if( m_rDoc.GotoOutline( aPos, aName ) )
      {
          nIdx = aPos.nNode.GetIndex();
          noBookmark = true;
      }
  }
  else if( sCmp == "graphic" )
  {
      SwNodeIndex* pIdx;
      OUString aName(BookmarkToWriter(aURL.copy(0, nPos)));
      const SwFlyFrameFormat* pFormat = m_rDoc.FindFlyByName(aName, SwNodeType::Grf);
      if (pFormat && nullptr != (pIdx = const_cast<SwNodeIndex*>(pFormat->GetContent().GetContentIdx())))
      {
          nIdx = pIdx->GetNext()->GetIndex();
          noBookmark = true;
      }
  }
  else if( sCmp == "frame" )
  {
      SwNodeIndex* pIdx;
      OUString aName(BookmarkToWriter(aURL.copy(0, nPos)));
      const SwFlyFrameFormat* pFormat = m_rDoc.FindFlyByName(aName, SwNodeType::Text);
      if (pFormat && nullptr != (pIdx = const_cast<SwNodeIndex*>(pFormat->GetContent().GetContentIdx())))
      {
          nIdx = pIdx->GetIndex() + 1;
          noBookmark = true;
      }
  }
  else if( sCmp == "ole" )
  {
      SwNodeIndex* pIdx;
      OUString aName(BookmarkToWriter(aURL.copy(0, nPos)));
      const SwFlyFrameFormat* pFormat = m_rDoc.FindFlyByName(aName, SwNodeType::Ole);
      if (pFormat && nullptr != (pIdx = const_cast<SwNodeIndex*>(pFormat->GetContent().GetContentIdx())))
      {
          nIdx = pIdx->GetNext()->GetIndex();
          noBookmark = true;
      }
  }
  else if( sCmp == "region" )
  {
      SwNodeIndex* pIdx;
      OUString aName(BookmarkToWriter(aURL.copy(0, nPos)));
      for (const SwSectionFormat* pFormat : m_rDoc.GetSections())
      {
          if (aName == pFormat->GetSection()->GetSectionName()
              && nullptr != (pIdx = const_cast<SwNodeIndex*>(pFormat->GetContent().GetContentIdx())))
          {
              nIdx = pIdx->GetIndex() + 1;
              noBookmark = true;
              break;
          }
      }
  }
  else if( sCmp == "table" )
  {
      OUString aName(BookmarkToWriter(aURL.copy(0, nPos)));
      const SwTable* pTable = SwTable::FindTable(m_rDoc.FindTableFormatByName(aName));
      if (pTable)
      {
          SwTableNode* pTableNode = const_cast<SwTableNode*>(pTable->GetTabSortBoxes()[1]->GetSttNd()->FindTableNode());
          if (pTableNode)
          {
              nIdx = pTableNode->GetIndex() + 2;
              noBookmark = true;
          }
      }
  }
  if (noBookmark)
  {
      aBookmarkPair aImplicitBookmark;
      aImplicitBookmark.first = aURL;
      aImplicitBookmark.second = nIdx;
      m_aImplicitBookmarks.push_back(aImplicitBookmark);
  }
3216}

3218void MSWordExportBase::CollectOutlineBookmarks(const SwDoc &rDoc)
3219{
  for (const SfxPoolItem* pItem : rDoc.GetAttrPool().GetItemSurrogates(RES_TXTATR_INETFMT))
  {
      auto pINetFormat = dynamic_cast<const SwFormatINetFormat*>(pItem);
      if (!pINetFormat)
          continue;

      const SwTextINetFormat* pTextAttr = pINetFormat->GetTextINetFormat();
      if (!pTextAttr)
          continue;

      const SwTextNode* pTextNd = pTextAttr->GetpTextNode();
      if (!pTextNd)
          continue;

      if (!pTextNd->GetNodes().IsDocNodes())
          continue;

      AddLinkTarget( pINetFormat->GetValue() );
  }

  for (const SfxPoolItem* pItem : rDoc.GetAttrPool().GetItemSurrogates(RES_URL))
  {
      auto pURL = dynamic_cast<const SwFormatURL*>(pItem);
      if (!pURL)
          continue;

      AddLinkTarget(pURL->GetURL());
      const ImageMap *pIMap = pURL->GetMap();
      if (!pIMap)
          continue;

      for (size_t i=0; i < pIMap->GetIMapObjectCount(); ++i)
      {
          const IMapObject* pObj = pIMap->GetIMapObject(i);
          if (!pObj)
              continue;
          AddLinkTarget( pObj->GetURL() );
      }
  }
3259}

3261namespace
3262{
  const sal_uLong WW_BLOCKSIZE = 0x200;

  ErrCode EncryptRC4(msfilter::MSCodec_Std97& rCtx, SvStream &rIn, SvStream &rOut)
  {
      sal_uLong nLen = rIn.TellEnd();
      rIn.Seek(0);

      sal_uInt8 in[WW_BLOCKSIZE];
      for (std::size_t nI = 0, nBlock = 0; nI < nLen; nI += WW_BLOCKSIZE, ++nBlock)
      {
          std::size_t nBS = std::min(nLen - nI, WW_BLOCKSIZE);
          nBS = rIn.ReadBytes(in, nBS);
          if (!rCtx.InitCipher(nBlock)) {
              return ERRCODE_IO_NOTSUPPORTEDErrCode( ErrCodeArea::Io, ErrCodeClass::NotSupported, 12 );
          }
          rCtx.Encode(in, nBS, in, nBS);
          rOut.WriteBytes(in, nBS);
      }
      return ERRCODE_NONEErrCode(0);
  }
3283}

3285ErrCode MSWordExportBase::ExportDocument( bool bWriteAll )
3286{
  m_nCharFormatStart = DEFAULT_STYLES_COUNT16;
  m_nFormatCollStart = m_nCharFormatStart + m_rDoc.GetCharFormats()->size() - 1;

  m_bStyDef = m_bBreakBefore = m_bOutKF =
      m_bOutFlyFrameAttrs = m_bOutPageDescs = m_bOutTable = m_bOutFirstPage =
      m_bOutGrf = m_bInWriteEscher = m_bStartTOX =
      m_bInWriteTOX = false;

  m_bFootnoteAtTextEnd = m_bEndAtTextEnd = true;

  m_pParentFrame = nullptr;
  m_pFlyOffset = nullptr;
  m_eNewAnchorType = RndStdIds::FLY_AT_PAGE;
  m_nTextTyp = TXT_MAINTEXT;
  m_nStyleBeforeFly = m_nLastFormatId = 0;
  m_pStyAttr = nullptr;
  m_pCurrentStyle = nullptr;
  m_pOutFormatNode = nullptr;
  m_pEscher = nullptr;
  m_pRedlAuthors = nullptr;
  m_aTOXArr.clear();

  if ( !m_pOLEExp )
  {
      sal_uInt32 nSvxMSDffOLEConvFlags = 0;
      const SvtFilterOptions& rOpt = SvtFilterOptions::Get();
      if ( rOpt.IsMath2MathType() )
          nSvxMSDffOLEConvFlags |= OLE_STARMATH_2_MATHTYPE0x0001;
      if ( rOpt.IsWriter2WinWord() )
          nSvxMSDffOLEConvFlags |= OLE_STARWRITER_2_WINWORD0x0002;
      if ( rOpt.IsCalc2Excel() )
          nSvxMSDffOLEConvFlags |= OLE_STARCALC_2_EXCEL0x0004;
      if ( rOpt.IsImpress2PowerPoint() )
          nSvxMSDffOLEConvFlags |= OLE_STARIMPRESS_2_POWERPOINT0x0008;

      m_pOLEExp.reset(new SvxMSExportOLEObjects( nSvxMSDffOLEConvFlags ));
  }

  if ( !m_pOCXExp && m_rDoc.GetDocShell() )
      m_pOCXExp.reset(new SwMSConvertControls(m_rDoc.GetDocShell(), m_pCurPam.get()));

  // #i81405# - Collect anchored objects before changing the redline mode.
  m_aFrames = GetFrames( m_rDoc, bWriteAll? nullptr : m_pOrigPam );

  m_nOrigRedlineFlags = m_rDoc.getIDocumentRedlineAccess().GetRedlineFlags();

  SwRootFrame const*const pLayout(m_rDoc.getIDocumentLayoutAccess().GetCurrentLayout());
  m_bOrigShowChanges = pLayout == nullptr || !pLayout->IsHideRedlines();

  if ( !m_rDoc.getIDocumentRedlineAccess().GetRedlineTable().empty() )
  {
      //restored to original state by SwWriter::Write
      m_rDoc.getIDocumentRedlineAccess().SetRedlineFlags(m_nOrigRedlineFlags |
                                                       RedlineFlags::ShowDelete |
                                                       RedlineFlags::ShowInsert);
  }

  // fix the SwPositions in m_aFrames after SetRedlineFlags
  UpdateFramePositions(m_aFrames);

  m_aFontHelper.InitFontTable(m_rDoc);
  GatherChapterFields();

  CollectOutlineBookmarks(m_rDoc);

  // make unique OrdNums (Z-Order) for all drawing-/fly Objects
  if ( m_rDoc.getIDocumentDrawModelAccess().GetDrawModel() )
      m_rDoc.getIDocumentDrawModelAccess().GetDrawModel()->GetPage( 0 )->RecalcObjOrdNums();

  ErrCode err = ExportDocument_Impl();

  m_aFrames.clear();

  // park m_pCurPam in a "safe place" now that document is fully exported
  // before toggling redline mode to avoid ~SwIndexReg assert e.g. export
  // ooo103014-1.odt to .doc
  // park m_pOrigPam as well, as needed for exporting abi9915-1.odt to doc
  m_pOrigPam->DeleteMark();
  *m_pOrigPam->GetPoint() = SwPosition(m_rDoc.GetNodes().GetEndOfContent());
  static_cast<SwPaM&>(*m_pCurPam) = *m_pOrigPam;

  m_rDoc.getIDocumentRedlineAccess().SetRedlineFlags(m_nOrigRedlineFlags);

  return err;
3371}

3373bool SwWW8Writer::InitStd97CodecUpdateMedium( ::msfilter::MSCodec_Std97& rCodec )
3374{
  uno::Sequence< beans::NamedValue > aEncryptionData;

  if ( mpMedium )
  {
      const SfxUnoAnyItem* pEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(mpMedium->GetItemSet(), SID_ENCRYPTIONDATA(5000 + 1722), false);
      if ( pEncryptionDataItem && ( pEncryptionDataItem->GetValue() >>= aEncryptionData ) && !rCodec.InitCodec( aEncryptionData ) )
      {
          OSL_ENSURE( false, "Unexpected EncryptionData!" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "3382" ": "), "%s", "Unexpected EncryptionData!"); } } while
 (false);
          aEncryptionData.realloc( 0 );
      }

      if ( !aEncryptionData.hasElements() )
      {
          // try to generate the encryption data based on password
          const SfxStringItem* pPasswordItem = SfxItemSet::GetItem<SfxStringItem>(mpMedium->GetItemSet(), SID_PASSWORD(((((10000 + 1499) + 1) + 499) + 1) + 36), false);
          if ( pPasswordItem && !pPasswordItem->GetValue().isEmpty() && pPasswordItem->GetValue().getLength() <= 15 )
          {
              // Generate random number with a seed of time as salt.
              rtlRandomPool aRandomPool = rtl_random_createPool ();
              sal_uInt8 pDocId[ 16 ];
              rtl_random_getBytes( aRandomPool, pDocId, 16 );

              rtl_random_destroyPool( aRandomPool );

              sal_uInt16 aPassword[16] = {};

              const OUString& sPassword(pPasswordItem->GetValue());
              for ( sal_Int32 nChar = 0; nChar < sPassword.getLength(); ++nChar )
                  aPassword[nChar] = sPassword[nChar];

              rCodec.InitKey( aPassword, pDocId );
              aEncryptionData = rCodec.GetEncryptionData();

              mpMedium->GetItemSet()->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA(5000 + 1722), uno::makeAny( aEncryptionData ) ) );
          }
      }

      if ( aEncryptionData.hasElements() )
          mpMedium->GetItemSet()->ClearItem( SID_PASSWORD(((((10000 + 1499) + 1) + 499) + 1) + 36) );
  }

  // nonempty encryption data means here that the codec was successfully initialized
  return aEncryptionData.hasElements();
3418}

3420ErrCode WW8Export::ExportDocument_Impl()
3421{
  PrepareStorage();

  pFib.reset(new WW8Fib(8, m_bDot));

  tools::SvRef<SotStorageStream> xWwStrm( GetWriter().GetStorage().OpenSotStream( m_aMainStg ) );
  tools::SvRef<SotStorageStream> xTableStrm( xWwStrm ), xDataStrm( xWwStrm );
  xWwStrm->SetBufferSize( 32768 );

  pFib->m_fWhichTableStm = true;
  xTableStrm = GetWriter().GetStorage().OpenSotStream(SL::a1Table, StreamMode::STD_WRITE);
  xDataStrm = GetWriter().GetStorage().OpenSotStream(SL::aData, StreamMode::STD_WRITE);

  xDataStrm->SetBufferSize( 32768 );  // for graphics
  xTableStrm->SetBufferSize( 16384 ); // for the Font-/Style-Table, etc.

  xTableStrm->SetEndian( SvStreamEndian::LITTLE );
  xDataStrm->SetEndian( SvStreamEndian::LITTLE );

  GetWriter().SetStream( xWwStrm.get() );
  pTableStrm = xTableStrm.get();
  pDataStrm = xDataStrm.get();

  Strm().SetEndian( SvStreamEndian::LITTLE );

  utl::TempFile aTempMain;
  aTempMain.EnableKillingFile();
  utl::TempFile aTempTable;
  aTempTable.EnableKillingFile();
  utl::TempFile aTempData;
  aTempData.EnableKillingFile();

  msfilter::MSCodec_Std97 aCtx;
  bool bEncrypt = GetWriter().InitStd97CodecUpdateMedium(aCtx);
  if ( bEncrypt )
  {
      GetWriter().SetStream(
          aTempMain.GetStream( StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE ) );

      pTableStrm = aTempTable.GetStream( StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE );

      pDataStrm = aTempData.GetStream( StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE );

      sal_uInt8 const aRC4EncryptionHeader[ 52 ] = {0};
      pTableStrm->WriteBytes(aRC4EncryptionHeader, 52);
  }

  // Default: "Standard"
  pSepx.reset(new WW8_WrPlcSepx( *this ));                         // Sections/headers/footers

  pFootnote.reset(new WW8_WrPlcFootnoteEdn( TXT_FTN ));                      // Footnotes
  pEdn.reset(new WW8_WrPlcFootnoteEdn( TXT_EDN ));                      // Endnotes
  m_pAtn = new WW8_WrPlcAnnotations;                                 // PostIts
  m_pFactoids.reset(new WW8_WrtFactoids); // Smart tags.
  m_pTextBxs = new WW8_WrPlcTextBoxes( TXT_TXTBOX );
  m_pHFTextBxs = new WW8_WrPlcTextBoxes( TXT_HFTXTBOX );

  m_pSdrObjs = new MainTextPlcDrawObj;   // Draw-/Fly-Objects for main text
  m_pHFSdrObjs = new HdFtPlcDrawObj;    // Draw-/Fly-Objects for header/footer

  m_pBkmks = new WW8_WrtBookmarks;                          // Bookmarks
  GetWriter().CreateBookmarkTable();

  m_pPapPlc.reset(new WW8_WrPlcPn( *this, PAP, pFib->m_fcMin ));
  m_pChpPlc.reset(new WW8_WrPlcPn( *this, CHP, pFib->m_fcMin ));
  pO.reset(new ww::bytes);
  m_pStyles.reset(new MSWordStyles( *this ));
  m_pFieldMain.reset(new WW8_WrPlcField( 2, TXT_MAINTEXT ));
  m_pFieldHdFt.reset(new WW8_WrPlcField( 2, TXT_HDFT ));
  m_pFieldFootnote.reset(new WW8_WrPlcField( 2, TXT_FTN ));
  m_pFieldEdn.reset(new WW8_WrPlcField( 2, TXT_EDN ));
  m_pFieldAtn.reset(new WW8_WrPlcField( 2, TXT_ATN ));
  m_pFieldTextBxs.reset(new WW8_WrPlcField( 2, TXT_TXTBOX ));
  m_pFieldHFTextBxs.reset(new WW8_WrPlcField( 2, TXT_HFTXTBOX ));

  m_pMagicTable.reset(new WW8_WrMagicTable);

  m_pGrf.reset(new SwWW8WrGrf( *this ));
  m_pPiece = new WW8_WrPct( pFib->m_fcMin );
  pDop.reset(new WW8Dop);

  pDop->fRevMarking = bool( RedlineFlags::On & m_nOrigRedlineFlags );
  SwRootFrame const*const pLayout(m_rDoc.getIDocumentLayoutAccess().GetCurrentLayout());
  pDop->fRMView = pLayout == nullptr || !pLayout->IsHideRedlines();
  pDop->fRMPrint = pDop->fRMView;

  // set AutoHyphenation flag if found in default para style
  const SfxPoolItem* pItem;
  SwTextFormatColl* pStdTextFormatColl =
      m_rDoc.getIDocumentStylePoolAccess().GetTextCollFromPool(RES_POOLCOLL_STANDARD, false);
  if (pStdTextFormatColl && SfxItemState::SET == pStdTextFormatColl->GetItemState(
      RES_PARATR_HYPHENZONE, false, &pItem))
  {
      pDop->fAutoHyphen = static_cast<const SvxHyphenZoneItem*>(pItem)->IsHyphen();
  }

  StoreDoc1();

  ErrCode err = ERRCODE_NONEErrCode(0);
  if ( bEncrypt )
  {
      SvStream *pStrmTemp, *pTableStrmTemp, *pDataStrmTemp;
      pStrmTemp = xWwStrm.get();
      pTableStrmTemp = xTableStrm.get();
      pDataStrmTemp = xDataStrm.get();

      if ( pDataStrmTemp && pDataStrmTemp != pStrmTemp) {
          err = EncryptRC4(aCtx, *pDataStrm, *pDataStrmTemp);
          if (err != ERRCODE_NONEErrCode(0)) {
              goto done;
          }
      }

      err = EncryptRC4(aCtx, *pTableStrm, *pTableStrmTemp);
      if (err != ERRCODE_NONEErrCode(0)) {
          goto done;
      }

      // Write Unencrypted Header 52 bytes to the start of the table stream
      // EncryptionVersionInfo (4 bytes): A Version structure where Version.vMajor MUST be 0x0001, and Version.vMinor MUST be 0x0001.
      pTableStrmTemp->Seek( 0 );
      pTableStrmTemp->WriteUInt32( 0x10001 ); // nEncType

      sal_uInt8 pDocId[16];
      aCtx.GetDocId( pDocId );

      sal_uInt8 pSaltData[16];
      sal_uInt8 pSaltDigest[16];
      aCtx.GetEncryptKey( pDocId, pSaltData, pSaltDigest );

      pTableStrmTemp->WriteBytes(pDocId, 16);
      pTableStrmTemp->WriteBytes(pSaltData, 16);
      pTableStrmTemp->WriteBytes(pSaltDigest, 16);

      err = EncryptRC4(aCtx, GetWriter().Strm(), *pStrmTemp);
      if (err != ERRCODE_NONEErrCode(0)) {
          goto done;
      }

      // Write Unencrypted Fib 68 bytes to the start of the workdocument stream
      pFib->m_fEncrypted = true; // fEncrypted indicates the document is encrypted.
      pFib->m_fObfuscated = false; // Must be 0 for RC4.
      pFib->m_nHash = 0x34; // encrypt header bytes count of table stream.
      pFib->m_nKey = 0; // lkey2 must be 0 for RC4.

      pStrmTemp->Seek( 0 );
      pFib->WriteHeader( *pStrmTemp );
  done:;
  }

  m_pGrf.reset();
  m_pMagicTable.reset();
  m_pFieldFootnote.reset();
  m_pFieldTextBxs.reset();
  m_pFieldHFTextBxs.reset();
  m_pFieldAtn.reset();
  m_pFieldEdn.reset();
  m_pFieldHdFt.reset();
  m_pFieldMain.reset();
  m_pStyles.reset();
  pO.reset();
  m_pChpPlc.reset();
  m_pPapPlc.reset();
  pSepx.reset();

  delete m_pRedlAuthors;
  delete m_pSdrObjs;
  delete m_pHFSdrObjs;
  delete m_pTextBxs;
  delete m_pHFTextBxs;
  delete m_pAtn;
  pEdn.reset();
  pFootnote.reset();
  delete m_pBkmks;
  delete m_pPiece;
  pDop.reset();
  pFib.reset();
  GetWriter().SetStream( nullptr );

  xWwStrm->SetBufferSize( 0 );
  xTableStrm->SetBufferSize( 0 );
  xDataStrm->SetBufferSize( 0 );
  if( 0 == pDataStrm->Seek( STREAM_SEEK_TO_END((sal_uInt64) 0xFFFFFFFFFFFFFFFFul) ))
  {
      xDataStrm.clear();
      pDataStrm = nullptr;
      GetWriter().GetStorage().Remove(SL::aData);
  }

  return err;
3611}

3613void WW8Export::PrepareStorage()
3614{
  static const sal_uInt8 pData[] =
  {
      0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
      0xFF, 0xFF, 0xFF, 0xFF, 0x06, 0x09, 0x02, 0x00,
      0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x46,

      0x18, 0x00, 0x00, 0x00,
      'M', 'i', 'c', 'r', 'o', 's', 'o', 'f',
      't', ' ', 'W', 'o', 'r', 'd', '-', 'D',
      'o', 'k', 'u', 'm', 'e', 'n', 't', 0x0,

      0x0A, 0x00, 0x00, 0x00,
      'M', 'S', 'W', 'o', 'r', 'd', 'D', 'o',
      'c', 0x0,

      0x10, 0x00, 0x00, 0x00,
      'W', 'o', 'r', 'd', '.', 'D', 'o', 'c',
      'u', 'm', 'e', 'n', 't', '.', '8', 0x0,

      0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  };

  SvGlobalName aGName(MSO_WW8_CLASSID0x00020906L, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00
, 0x00, 0x46);
  GetWriter().GetStorage().SetClass(
      aGName, SotClipboardFormatId::NONE, "Microsoft Word-Document");
  tools::SvRef<SotStorageStream> xStor( GetWriter().GetStorage().OpenSotStream(sCompObj"\1CompObj") );
  xStor->WriteBytes(pData, sizeof(pData));

  SwDocShell* pDocShell = m_rDoc.GetDocShell ();
  OSL_ENSURE(pDocShell, "no SwDocShell")do { if (true && (!(pDocShell))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "3646" ": "), "%s", "no SwDocShell"); } } while (false);

  if (!pDocShell)        return;

  uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
      pDocShell->GetModel(), uno::UNO_QUERY_THROW);
  uno::Reference<document::XDocumentProperties> xDocProps(
      xDPS->getDocumentProperties());
  OSL_ENSURE(xDocProps.is(), "DocumentProperties is null")do { if (true && (!(xDocProps.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "3654" ": "), "%s", "DocumentProperties is null"); } } while
 (false);

  if (!xDocProps.is())
      return;

  if ( SvtFilterOptions::Get().IsEnableWordPreview() )
  {
      std::shared_ptr<GDIMetaFile> xMetaFile =
          pDocShell->GetPreviewMetaFile();
      uno::Sequence<sal_Int8> metaFile(
          sfx2::convertMetaFile(xMetaFile.get()));
      sfx2::SaveOlePropertySet(xDocProps, &GetWriter().GetStorage(), &metaFile);
  }
  else
      sfx2::SaveOlePropertySet( xDocProps, &GetWriter().GetStorage() );
3669}

3671ErrCode SwWW8Writer::WriteStorage()
3672{
  tools::SvRef<SotStorage> pOrigStg;
  uno::Reference< packages::XPackageEncryption > xPackageEncryption;
  std::shared_ptr<SvStream> pSotStorageStream;
  uno::Sequence< beans::NamedValue > aEncryptionData;
  if (mpMedium)
  {
      // Check for specific encryption requests
      const SfxUnoAnyItem* pEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(mpMedium->GetItemSet(), SID_ENCRYPTIONDATA(5000 + 1722), false);
      if (pEncryptionDataItem && (pEncryptionDataItem->GetValue() >>= aEncryptionData))
      {
          ::comphelper::SequenceAsHashMap aHashData(aEncryptionData);
          OUString sCryptoType = aHashData.getUnpackedValueOrDefault("CryptoType", OUString());

          if (sCryptoType.getLength())
          {
              uno::Reference<uno::XComponentContext> xComponentContext(comphelper::getProcessComponentContext());
              uno::Sequence<uno::Any> aArguments{
                  uno::makeAny(beans::NamedValue("Binary", uno::makeAny(true))) };
              xPackageEncryption.set(
                  xComponentContext->getServiceManager()->createInstanceWithArgumentsAndContext(
                      "com.sun.star.comp.oox.crypto." + sCryptoType, aArguments, xComponentContext), uno::UNO_QUERY);

              if (xPackageEncryption.is())
              {
                  // We have an encryptor
                  // Create new temporary storage for content
                  pOrigStg = m_pStg;
                  pSotStorageStream = std::make_shared<SvMemoryStream>();
                  m_pStg = new SotStorage(*pSotStorageStream);
              }
          }
      }
  }

  ErrCode nErrorCode = WriteStorageImpl();

  if (xPackageEncryption.is())
  {
      m_pStg->Commit();
      pSotStorageStream->Seek(0);

      // Encrypt data written into temporary storage
      xPackageEncryption->setupEncryption(aEncryptionData);

      uno::Reference<io::XInputStream > xInputStream(new utl::OSeekableInputStreamWrapper(pSotStorageStream.get(), false));
      uno::Sequence<beans::NamedValue> aStreams = xPackageEncryption->encrypt(xInputStream);

      m_pStg = pOrigStg;
      for (const beans::NamedValue & aStreamData : std::as_const(aStreams))
      {
          // To avoid long paths split and open substorages recursively
          // Splitting paths manually, since comphelper::string::split is trimming special characters like \0x01, \0x09
          tools::SvRef<SotStorage> pStorage = m_pStg.get();
          OUString sFileName;
          sal_Int32 idx = 0;
          while (pStorage && idx >= 0)
          {
              OUString sPathElem = aStreamData.Name.getToken(0, L'/', idx);
              if (!sPathElem.isEmpty())
              {
                  if (idx < 0)
                  {
                      sFileName = sPathElem;
                  }
                  else
                  {
                      pStorage = pStorage->OpenSotStorage(sPathElem);
                      if (!pStorage)
                          break;
                  }
              }
          };

          if (!pStorage)
          {
              nErrorCode = ERRCODE_IO_GENERALErrCode( ErrCodeArea::Io, ErrCodeClass::General, 13 );
              break;
          }

          tools::SvRef<SotStorageStream> pStream = pStorage->OpenSotStream(sFileName);
          if (!pStream)
          {
              nErrorCode = ERRCODE_IO_GENERALErrCode( ErrCodeArea::Io, ErrCodeClass::General, 13 );
              break;
          }
          uno::Sequence<sal_Int8> aStreamContent;
          aStreamData.Value >>= aStreamContent;
          size_t nBytesWritten = pStream->WriteBytes(aStreamContent.getArray(), aStreamContent.getLength());
          if (nBytesWritten != static_cast<size_t>(aStreamContent.getLength()))
          {
              nErrorCode = ERRCODE_IO_CANTWRITEErrCode( ErrCodeArea::Io, ErrCodeClass::Write, 16 );
              break;
          }
      }
  }

  return nErrorCode;
3770}
3771ErrCode SwWW8Writer::WriteStorageImpl()
3772{
  // #i34818# - update layout (if present), for SwWriteTable
  SwViewShell* pViewShell = m_pDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
  if( pViewShell != nullptr )
      pViewShell->CalcLayout();

  long nMaxNode = m_pDoc->GetNodes().Count();
  ::StartProgress( STR_STATSTR_W4WWRITEreinterpret_cast<char const *>("STR_STATSTR_W4WWRITE" "\004"
 u8"Exporting document..."), 0, nMaxNode, m_pDoc->GetDocShell() );

  // Respect table at the beginning of the document
  {
      SwTableNode* pTNd = m_pCurrentPam->GetNode().FindTableNode();
      if( pTNd && m_bWriteAll )
          // start with the table node !!
          m_pCurrentPam->GetPoint()->nNode = *pTNd;
  }

  // Do the actual export
  ErrCode err = ERRCODE_NONEErrCode(0);
  {
      bool bDot = mpMedium->GetFilter()->GetName().endsWith("Vorlage");
      WW8Export aExport(this, *m_pDoc, m_pCurrentPam, m_pOrigPam, bDot);
      m_pExport = &aExport;
      err = aExport.ExportDocument( m_bWriteAll );
      m_pExport = nullptr;
  }

  ::EndProgress( m_pDoc->GetDocShell() );
  return err;
3801}

3803ErrCode SwWW8Writer::WriteMedium( SfxMedium& )
3804{
  return WriteStorage();
3806}

3808ErrCode SwWW8Writer::Write( SwPaM& rPaM, SfxMedium& rMed,
                        const OUString* pFileName )
3810{
  mpMedium = &rMed;
  ErrCode nRet = StgWriter::Write( rPaM, rMed, pFileName );
  mpMedium = nullptr;
  return nRet;
3815}

3817MSWordExportBase::MSWordExportBase( SwDoc& rDocument, std::shared_ptr<SwUnoCursor> & pCurrentPam, SwPaM* pOriginalPam )
  : m_aMainStg(sMainStreamOUString("WordDocument"))
  , m_pISet(nullptr)
  , m_pPiece(nullptr)
  , m_pTopNodeOfHdFtPage(nullptr)
  , m_pBkmks(nullptr)
  , m_pRedlAuthors(nullptr)
  , m_pTableInfo(std::make_shared<ww8::WW8TableInfo>())
  , m_nCharFormatStart(0)
  , m_nFormatCollStart(0)
  , m_nStyleBeforeFly(0)
  , m_nLastFormatId(0)
  , m_nUniqueList(0)
  , m_nHdFtIndex(0)
  , m_nOrigRedlineFlags(RedlineFlags::NONE)
  , m_bOrigShowChanges(true)
  , m_pCurrentPageDesc(nullptr)
  , m_bFirstTOCNodeWithSection(false)
  , m_pChpIter(nullptr)
  , m_pAtn(nullptr)
  , m_pTextBxs(nullptr)
  , m_pHFTextBxs(nullptr)
  , m_pParentFrame(nullptr)
  , m_pFlyOffset(nullptr)
  , m_eNewAnchorType(RndStdIds::FLY_AS_CHAR)
  , m_pStyAttr(nullptr)
  , m_pOutFormatNode(nullptr)
  , m_pCurrentStyle(nullptr)
  , m_pSdrObjs(nullptr)
  , m_pHFSdrObjs(nullptr)
  , m_pEscher(nullptr)
  , m_nTextTyp(0)
  , m_bStyDef(false)
  , m_bBreakBefore(false)
  , m_bOutKF(false)
  , m_bOutFlyFrameAttrs(false)
  , m_bOutPageDescs(false)
  , m_bOutFirstPage(false)
  , m_bOutTable(false)
  , m_bOutGrf(false)
  , m_bInWriteEscher(false)
  , m_bStartTOX(false)
  , m_bInWriteTOX(false)
  , m_bFootnoteAtTextEnd(false)
  , m_bEndAtTextEnd(false)
  , m_bHasHdr(false)
  , m_bHasFtr(false)
  , m_bSubstituteBullets(true)
  , m_bTabInTOC(false)
  , m_bHideTabLeaderAndPageNumbers(false)
  , m_bExportModeRTF(false)
  , m_bFontSizeWritten(false)
  , m_bAddFootnoteTab(false)
  , m_rDoc(rDocument)
  , m_nCurStart(pCurrentPam->GetPoint()->nNode.GetIndex())
  , m_nCurEnd(pCurrentPam->GetMark()->nNode.GetIndex())
  , m_pCurPam(pCurrentPam)
  , m_pOrigPam(pOriginalPam)
3875{
3876}

3878MSWordExportBase::~MSWordExportBase()
3879{
  if (m_pUsedNumTable)           // all used NumRules
  {
      // clear the part of the list array that was copied from the document
      // - it's an auto delete array, so the rest of the array which are
      // duplicated lists that were added during the export will be deleted.
      m_pUsedNumTable->erase(m_pUsedNumTable->begin(), m_pUsedNumTable->begin() + m_pUsedNumTable->size() - m_nUniqueList);
      m_pUsedNumTable.reset();
  }
  m_pOLEExp.reset();
  m_pOCXExp.reset();
3890}

3892WW8Export::WW8Export( SwWW8Writer *pWriter,
      SwDoc& rDocument, std::shared_ptr<SwUnoCursor> & pCurrentPam, SwPaM* pOriginalPam,
      bool bDot )
  : MSWordExportBase( rDocument, pCurrentPam, pOriginalPam )
  , pTableStrm(nullptr)
  , pDataStrm(nullptr)
  , m_bDot(bDot)
  , m_pWriter(pWriter)
  , m_pAttrOutput(new WW8AttributeOutput(*this))
3901{
3902}

3904WW8Export::~WW8Export()
3905{
3906}

3908AttributeOutputBase& WW8Export::AttrOutput() const
3909{
  return *m_pAttrOutput;
3911}

3913MSWordSections& WW8Export::Sections() const
3914{
  return *pSepx;
3916}

3918SwWW8Writer::SwWW8Writer(const OUString& rFltName, const OUString& rBaseURL)
  : StgWriter(),
    m_pExport( nullptr ),
    mpMedium( nullptr )
3922{
  assert(rFltName == FILTER_WW8)(static_cast <bool> (rFltName == "CWW8") ? void (0) : __assert_fail
 ("rFltName == FILTER_WW8", "/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
, 3923, __extension__ __PRETTY_FUNCTION__)); // WW6/7 export was removed
  (void)rFltName;
  SetBaseURL( rBaseURL );
3926}

3928SwWW8Writer::~SwWW8Writer()
3929{
3930}

3932extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) sal_uInt32 SaveOrDelMSVBAStorage_ww8( SfxObjectShell& rDoc, SotStorage& rStor, sal_Bool bSaveInto, const OUString& rStorageName )
3933{
  SvxImportMSVBasic aTmp( rDoc, rStor );
  return sal_uInt32(aTmp.SaveOrDelMSVBAStorage( bSaveInto, rStorageName ));
3936}

3938extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) void ExportDOC( const OUString& rFltName, const OUString& rBaseURL, WriterRef& xRet )
3939{
  xRet = new SwWW8Writer( rFltName, rBaseURL );
3941}

3943extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) sal_uInt32 GetSaveWarningOfMSVBAStorage_ww8(  SfxObjectShell &rDocS )
3944{
  return sal_uInt32(SvxImportMSVBasic::GetSaveWarningOfMSVBAStorage( rDocS ));
3946}

3948bool WW8_WrPlcFootnoteEdn::WriteText( WW8Export& rWrt )
3949{
  bool bRet = false;
  if (TXT_FTN == nTyp)
  {
      bRet = WriteGenericText( rWrt, TXT_FTN, rWrt.pFib->m_ccpFootnote );
      rWrt.m_pFieldFootnote->Finish( rWrt.Fc2Cp( rWrt.Strm().Tell() ),
                          rWrt.pFib->m_ccpText );
  }
  else
  {
      bRet = WriteGenericText( rWrt, TXT_EDN, rWrt.pFib->m_ccpEdn );
      rWrt.m_pFieldEdn->Finish( rWrt.Fc2Cp( rWrt.Strm().Tell() ),
                          rWrt.pFib->m_ccpText + rWrt.pFib->m_ccpFootnote
                          + rWrt.pFib->m_ccpHdr + rWrt.pFib->m_ccpAtn );
  }
  return bRet;
3965}

3967void WW8_WrPlcFootnoteEdn::WritePlc( WW8Export& rWrt ) const
3968{
  if( TXT_FTN == nTyp )
  {
      WriteGenericPlc( rWrt, TXT_FTN, rWrt.pFib->m_fcPlcffndText,
          rWrt.pFib->m_lcbPlcffndText, rWrt.pFib->m_fcPlcffndRef,
          rWrt.pFib->m_lcbPlcffndRef );
  }
  else
  {
      WriteGenericPlc( rWrt, TXT_EDN, rWrt.pFib->m_fcPlcfendText,
          rWrt.pFib->m_lcbPlcfendText, rWrt.pFib->m_fcPlcfendRef,
          rWrt.pFib->m_lcbPlcfendRef );
  }
3981}

3983bool WW8_WrPlcAnnotations::WriteText( WW8Export& rWrt )
3984{
  bool bRet = WriteGenericText( rWrt, TXT_ATN, rWrt.pFib->m_ccpAtn );
  rWrt.m_pFieldAtn->Finish( rWrt.Fc2Cp( rWrt.Strm().Tell() ),
                      rWrt.pFib->m_ccpText + rWrt.pFib->m_ccpFootnote
                      + rWrt.pFib->m_ccpHdr );
  return bRet;
3990}

3992void WW8_WrPlcAnnotations::WritePlc( WW8Export& rWrt ) const
3993{
  WriteGenericPlc( rWrt, TXT_ATN, rWrt.pFib->m_fcPlcfandText,
      rWrt.pFib->m_lcbPlcfandText, rWrt.pFib->m_fcPlcfandRef,
      rWrt.pFib->m_lcbPlcfandRef );
3997}

3999void WW8_WrPlcTextBoxes::WritePlc( WW8Export& rWrt ) const
4000{
  if( TXT_TXTBOX == nTyp )
  {
      WriteGenericPlc( rWrt, nTyp, rWrt.pFib->m_fcPlcftxbxBkd,
          rWrt.pFib->m_lcbPlcftxbxBkd, rWrt.pFib->m_fcPlcftxbxText,
          rWrt.pFib->m_lcbPlcftxbxText );
  }
  else
  {
      WriteGenericPlc( rWrt, nTyp, rWrt.pFib->m_fcPlcfHdrtxbxBkd,
          rWrt.pFib->m_lcbPlcfHdrtxbxBkd, rWrt.pFib->m_fcPlcfHdrtxbxText,
          rWrt.pFib->m_lcbPlcfHdrtxbxText );
  }
4013}

4015void WW8Export::RestoreMacroCmds()
4016{
  pFib->m_fcCmds = pTableStrm->Tell();

  uno::Reference < embed::XStorage > xSrcRoot(m_rDoc.GetDocShell()->GetStorage());
  try
  {
      uno::Reference < io::XStream > xSrcStream =
              xSrcRoot->openStreamElement( SL::aMSMacroCmds, embed::ElementModes::READ );
      std::unique_ptr<SvStream> pStream = ::utl::UcbStreamHelper::CreateStream( xSrcStream );

      if ( pStream && ERRCODE_NONEErrCode(0) == pStream->GetError())
      {
          pFib->m_lcbCmds = pStream->TellEnd();
          pStream->Seek(0);

          std::unique_ptr<sal_uInt8[]> pBuffer( new sal_uInt8[pFib->m_lcbCmds] );
          bool bReadOk = checkRead(*pStream, pBuffer.get(), pFib->m_lcbCmds);
          if (bReadOk)
              pTableStrm->WriteBytes(pBuffer.get(), pFib->m_lcbCmds);
      }
  }
  catch ( const uno::Exception& )
  {
  }

  // set len to FIB
  pFib->m_lcbCmds = pTableStrm->Tell() - pFib->m_fcCmds;
4043}

4045void WW8SHDLong::Write( WW8Export& rExport )
4046{
  rExport.InsUInt32( m_cvFore );
  rExport.InsUInt32( m_cvBack );
  rExport.InsUInt16( 0 ); // ipat
4050}

4052void WW8Export::WriteFormData( const ::sw::mark::IFieldmark& rFieldmark )
4053{
  const ::sw::mark::IFieldmark* pFieldmark = &rFieldmark;
  const ::sw::mark::ICheckboxFieldmark* pAsCheckbox = dynamic_cast< const ::sw::mark::ICheckboxFieldmark* >( pFieldmark );

  if ( ! ( rFieldmark.GetFieldname() == ODF_FORMTEXT"vnd.oasis.opendocument.field.FORMTEXT" ||
              rFieldmark.GetFieldname() == ODF_FORMDROPDOWN"vnd.oasis.opendocument.field.FORMDROPDOWN" ||
              rFieldmark.GetFieldname() == ODF_FORMCHECKBOX"vnd.oasis.opendocument.field.FORMCHECKBOX" ) )
  {
      SAL_WARN( "sw.ww8", "unknown field type" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "unknown field type")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4061" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "unknown field type"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "unknown field type"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4061" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "unknown field type") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_WARN), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4061" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "unknown field type"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "unknown field type"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4061" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      return;
  }

  int type = 0; // TextFieldmark
  if ( pAsCheckbox )
      type = 1;
  if ( rFieldmark.GetFieldname() == ODF_FORMDROPDOWN"vnd.oasis.opendocument.field.FORMDROPDOWN" )
      type=2;

  ::sw::mark::IFieldmark::parameter_map_t::const_iterator pParameter = rFieldmark.GetParameters()->find("name");
  OUString ffname;
  if ( pParameter != rFieldmark.GetParameters()->end() )
  {
      OUString aName;
      pParameter->second >>= aName;
      const sal_Int32 nLen = std::min( sal_Int32(20), aName.getLength() );
      ffname = aName.copy(0, nLen);
  }

  sal_uInt64 nDataStt = pDataStrm->Tell();
  m_pChpPlc->AppendFkpEntry(Strm().Tell());

  WriteChar(0x01);
  static sal_uInt8 aArr1[] =
  {
      0x03, 0x6a, 0,0,0,0,    // sprmCPicLocation

      0x06, 0x08, 0x01,       // sprmCFData
      0x55, 0x08, 0x01,       // sprmCFSpec
      0x02, 0x08, 0x01        // sprmCFFieldVanish
  };
  sal_uInt8* pDataAdr = aArr1 + 2;
  Set_UInt32(pDataAdr, nDataStt);

  m_pChpPlc->AppendFkpEntry( Strm().Tell(), sizeof( aArr1 ), aArr1 );

  struct FFDataHeader
  {
      sal_uInt32 version;
      sal_uInt16 bits;
      sal_uInt16 cch;
      sal_uInt16 hps;
      FFDataHeader() : version( 0xFFFFFFFF ), bits(0), cch(0), hps(0) {}
  };

  FFDataHeader aFieldHeader;
  aFieldHeader.bits |= (type & 0x03);

  sal_Int32 ffres = 0; // rFieldmark.GetFFRes();
  if ( pAsCheckbox && pAsCheckbox->IsChecked() )
      ffres = 1;
  else if ( type == 2 )
  {
      ::sw::mark::IFieldmark::parameter_map_t::const_iterator pResParameter = rFieldmark.GetParameters()->find(ODF_FORMDROPDOWN_RESULT"Dropdown_Selected");
      if(pResParameter != rFieldmark.GetParameters()->end())
          pResParameter->second >>= ffres;
      else
          ffres = 0;
  }
  aFieldHeader.bits |= ( (ffres<<2) & 0x7C );

  OUString ffdeftext;
  OUString ffformat;
  OUString ffhelptext = rFieldmark.GetFieldHelptext();
  if ( ffhelptext.getLength() > 255 )
      ffhelptext = ffhelptext.copy(0, 255);
  OUString ffstattext;
  OUString ffentrymcr;
  OUString ffexitmcr;
  if (type == 0) // iTypeText
  {
      sal_uInt16 nType = 0;
      pParameter = rFieldmark.GetParameters()->find("Type");
      if ( pParameter != rFieldmark.GetParameters()->end() )
      {
          OUString aType;
          pParameter->second >>= aType;
          if ( aType == "number" )            nType = 1;
          else if ( aType == "date" )         nType = 2;
          else if ( aType == "currentTime" )  nType = 3;
          else if ( aType == "currentDate" )  nType = 4;
          else if ( aType == "calculated" )   nType = 5;
          aFieldHeader.bits |= nType<<11; // FFDataBits-F  00111000 00000000
      }

      if ( nType < 3 || nType == 5 )  // not currentTime or currentDate
      {
          pParameter = rFieldmark.GetParameters()->find("Content");
          if ( pParameter != rFieldmark.GetParameters()->end() )
          {
              OUString aDefaultText;
              pParameter->second >>= aDefaultText;
              const sal_Int32 nLen = std::min( sal_Int32(255), aDefaultText.getLength() );
              ffdeftext = aDefaultText.copy (0, nLen);
          }
      }

      pParameter = rFieldmark.GetParameters()->find("MaxLength");
      if ( pParameter != rFieldmark.GetParameters()->end() )
      {
          sal_uInt16 nLength = 0;
          pParameter->second >>= nLength;
          nLength = std::min( sal_uInt16(32767), nLength );
          aFieldHeader.cch = nLength;
      }

      pParameter = rFieldmark.GetParameters()->find("Format");
      if ( pParameter != rFieldmark.GetParameters()->end() )
      {
          OUString aFormat;
          pParameter->second >>= aFormat;
          const sal_Int32 nLen = std::min( sal_Int32(64), aFormat.getLength() );
          ffformat = aFormat.copy(0, nLen);
      }
  }

  pParameter = rFieldmark.GetParameters()->find("Help"); //help
  if ( ffhelptext.isEmpty() && pParameter != rFieldmark.GetParameters()->end() )
  {
      OUString aHelpText;
      pParameter->second >>= aHelpText;
      const sal_Int32 nLen = std::min( sal_Int32(255), aHelpText.getLength() );
      ffhelptext = aHelpText.copy (0, nLen);
  }
  if ( !ffhelptext.isEmpty() )
      aFieldHeader.bits |= 0x1<<7;

  pParameter = rFieldmark.GetParameters()->find("Description"); // doc tooltip
  if ( pParameter == rFieldmark.GetParameters()->end() )
      pParameter = rFieldmark.GetParameters()->find("Hint"); //docx tooltip
  if ( pParameter != rFieldmark.GetParameters()->end() )
  {
      OUString aStatusText;
      pParameter->second >>= aStatusText;
      const sal_Int32 nLen = std::min( sal_Int32(138), aStatusText.getLength() );
      ffstattext = aStatusText.copy (0, nLen);
  }
  if ( !ffstattext.isEmpty() )
      aFieldHeader.bits |= 0x1<<8;

  pParameter = rFieldmark.GetParameters()->find("EntryMacro");
  if ( pParameter != rFieldmark.GetParameters()->end() )
  {
      OUString aEntryMacro;
      pParameter->second >>= aEntryMacro;
      const sal_Int32 nLen = std::min( sal_Int32(32), aEntryMacro.getLength() );
      ffentrymcr = aEntryMacro.copy (0, nLen);
  }

  pParameter = rFieldmark.GetParameters()->find("ExitMacro");
  if ( pParameter != rFieldmark.GetParameters()->end() )
  {
      OUString aExitMacro;
      pParameter->second >>= aExitMacro;
      const sal_Int32 nLen = std::min( sal_Int32(32), aExitMacro.getLength() );
      ffexitmcr = aExitMacro.copy (0, nLen);
  }

  std::vector< OUString > aListItems;
  if (type==2)
  {
      aFieldHeader.bits |= 0x8000; // ffhaslistbox
      const ::sw::mark::IFieldmark::parameter_map_t* const pParameters = rFieldmark.GetParameters();
      ::sw::mark::IFieldmark::parameter_map_t::const_iterator pListEntries = pParameters->find(ODF_FORMDROPDOWN_LISTENTRY"Dropdown_ListEntry");
      if(pListEntries != pParameters->end())
      {
          uno::Sequence< OUString > vListEntries;
          pListEntries->second >>= vListEntries;
          copy(vListEntries.begin(), vListEntries.end(), back_inserter(aListItems));
      }
  }

  const sal_uInt8 aFieldData[] =
  {
      0x44,0,         // the start of "next" data
      0,0,0,0,0,0,0,0,0,0,                // PIC-Structure!  /10
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,    //  |              /16
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,    //  |              /16
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,    //  |              /16
      0,0,0,0,                            // /               /4
  };
  sal_uInt32 slen = sizeof(sal_uInt32)
      + sizeof(aFieldData)
      + sizeof( aFieldHeader.version ) + sizeof( aFieldHeader.bits ) + sizeof( aFieldHeader.cch ) + sizeof( aFieldHeader.hps )
      + 2*ffname.getLength() + 4
      + 2*ffformat.getLength() + 4
      + 2*ffhelptext.getLength() + 4
      + 2*ffstattext.getLength() + 4
      + 2*ffentrymcr.getLength() + 4
      + 2*ffexitmcr.getLength() + 4;
  if ( type )
      slen += 2; // wDef
  else
      slen += 2*ffdeftext.getLength() + 4; //xstzTextDef
  if ( type==2 ) {
      slen += 2; // sttb ( fExtend )
      slen += 4; // for num of list items
      const int items = aListItems.size();
      for( int i = 0; i < items; i++ ) {
          OUString item = aListItems[i];
          slen += 2 * item.getLength() + 2;
      }
  }

  pDataStrm->WriteUInt32( slen );

  int len = sizeof( aFieldData );
  OSL_ENSURE( len == 0x44-sizeof(sal_uInt32), "SwWW8Writer::WriteFormData(..) - wrong aFieldData length" )do { if (true && (!(len == 0x44-sizeof(sal_uInt32))))
 { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4269" ": "), "%s", "SwWW8Writer::WriteFormData(..) - wrong aFieldData length"
); } } while (false);
  pDataStrm->WriteBytes( aFieldData, len );

  pDataStrm->WriteUInt32( aFieldHeader.version ).WriteUInt16( aFieldHeader.bits ).WriteUInt16( aFieldHeader.cch ).WriteUInt16( aFieldHeader.hps );

  SwWW8Writer::WriteString_xstz( *pDataStrm, ffname, true ); // Form field name

  if ( !type )
      SwWW8Writer::WriteString_xstz( *pDataStrm, ffdeftext, true );
  if ( type )
      pDataStrm->WriteUInt16( 0 );

  SwWW8Writer::WriteString_xstz( *pDataStrm, ffformat, true );
  SwWW8Writer::WriteString_xstz( *pDataStrm, ffhelptext, true );
  SwWW8Writer::WriteString_xstz( *pDataStrm, ffstattext, true );
  SwWW8Writer::WriteString_xstz( *pDataStrm, ffentrymcr, true );
  SwWW8Writer::WriteString_xstz( *pDataStrm, ffexitmcr, true );
  if (type==2) {
      pDataStrm->WriteUInt16( 0xFFFF );
      const int items=aListItems.size();
      pDataStrm->WriteUInt32( items );
      for(int i=0;i<items;i++) {
          OUString item=aListItems[i];
          SwWW8Writer::WriteString_xstz( *pDataStrm, item, false );
      }
  }
4295}

4297void WW8Export::WriteHyperlinkData( const sw::mark::IFieldmark& /*rFieldmark*/ )
4298{
  //@TODO implement me !!!
4300}

4302void WW8AttributeOutput::TableNodeInfoInner( ww8::WW8TableNodeInfoInner::Pointer_t pNodeInfoInner )
4303{
  SVBT16 nStyle;
  ShortToSVBT16( m_rWW8Export.m_nStyleBeforeFly, nStyle );

4307#ifdef DBG_UTIL
  SAL_INFO( "sw.ww8", "<OutWW8_TableNodeInfoInner>" << pNodeInfoInner->toString())do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "<OutWW8_TableNodeInfoInner>"
 << pNodeInfoInner->toString()) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4308" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<OutWW8_TableNodeInfoInner>" <<
 pNodeInfoInner->toString()), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "<OutWW8_TableNodeInfoInner>"
 << pNodeInfoInner->toString(); ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4308" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "<OutWW8_TableNodeInfoInner>" << pNodeInfoInner
->toString()) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4308" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<OutWW8_TableNodeInfoInner>" <<
 pNodeInfoInner->toString()), 0); } else { ::std::ostringstream
 sal_detail_stream; sal_detail_stream << "<OutWW8_TableNodeInfoInner>"
 << pNodeInfoInner->toString(); ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4308" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4309#endif

  m_rWW8Export.pO->clear();

  sal_uInt32 nShadowsBefore = pNodeInfoInner->getShadowsBefore();
  if (nShadowsBefore > 0)
  {
      ww8::WW8TableNodeInfoInner::Pointer_t
          pTmpNodeInfoInner = std::make_shared<ww8::WW8TableNodeInfoInner>(nullptr);

      pTmpNodeInfoInner->setDepth(pNodeInfoInner->getDepth());
      pTmpNodeInfoInner->setEndOfCell(true);

      for (sal_uInt32 n = 0; n < nShadowsBefore; ++n)
      {
          m_rWW8Export.WriteCR(pTmpNodeInfoInner);

          m_rWW8Export.pO->insert( m_rWW8Export.pO->end(), nStyle, nStyle+2 );     // Style #
          TableInfoCell(pTmpNodeInfoInner);
          m_rWW8Export.m_pPapPlc->AppendFkpEntry
              ( m_rWW8Export.Strm().Tell(), m_rWW8Export.pO->size(), m_rWW8Export.pO->data() );

          m_rWW8Export.pO->clear();
      }
  }

  if (pNodeInfoInner->isEndOfCell())
  {
      SAL_INFO( "sw.ww8", "<endOfCell/>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "<endOfCell/>")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4337" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<endOfCell/>"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<endOfCell/>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4337" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "<endOfCell/>") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4337" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<endOfCell/>"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<endOfCell/>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4337" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

      m_rWW8Export.WriteCR(pNodeInfoInner);

      m_rWW8Export.pO->insert( m_rWW8Export.pO->end(), nStyle, nStyle+2 );     // Style #
      TableInfoCell(pNodeInfoInner);
      m_rWW8Export.m_pPapPlc->AppendFkpEntry( m_rWW8Export.Strm().Tell(), m_rWW8Export.pO->size(), m_rWW8Export.pO->data() );

      m_rWW8Export.pO->clear();
  }

  sal_uInt32 nShadowsAfter = pNodeInfoInner->getShadowsAfter();
  if (nShadowsAfter > 0)
  {
      ww8::WW8TableNodeInfoInner::Pointer_t
          pTmpNodeInfoInner= std::make_shared<ww8::WW8TableNodeInfoInner>(nullptr);

      pTmpNodeInfoInner->setDepth(pNodeInfoInner->getDepth());
      pTmpNodeInfoInner->setEndOfCell(true);

      for (sal_uInt32 n = 0; n < nShadowsAfter; ++n)
      {
          m_rWW8Export.WriteCR(pTmpNodeInfoInner);

          m_rWW8Export.pO->insert( m_rWW8Export.pO->end(), nStyle, nStyle+2 );     // Style #
          TableInfoCell(pTmpNodeInfoInner);
          m_rWW8Export.m_pPapPlc->AppendFkpEntry( m_rWW8Export.Strm().Tell(), m_rWW8Export.pO->size(), m_rWW8Export.pO->data() );

          m_rWW8Export.pO->clear();
      }
  }

  if (pNodeInfoInner->isEndOfLine())
  {
      SAL_INFO( "sw.ww8", "<endOfLine/>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "<endOfLine/>")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4371" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<endOfLine/>"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<endOfLine/>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4371" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "<endOfLine/>") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4371" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<endOfLine/>"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "<endOfLine/>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4371" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);

      TableRowEnd(pNodeInfoInner->getDepth());

      ShortToSVBT16(0, nStyle);
      m_rWW8Export.pO->insert( m_rWW8Export.pO->end(), nStyle, nStyle+2 );     // Style #
      TableInfoRow(pNodeInfoInner);
      m_rWW8Export.m_pPapPlc->AppendFkpEntry( m_rWW8Export.Strm().Tell(), m_rWW8Export.pO->size(), m_rWW8Export.pO->data() );

      m_rWW8Export.pO->clear();
  }
  SAL_INFO( "sw.ww8", "</OutWW8_TableNodeInfoInner>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "</OutWW8_TableNodeInfoInner>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4382" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutWW8_TableNodeInfoInner>"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "</OutWW8_TableNodeInfoInner>"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4382" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "</OutWW8_TableNodeInfoInner>") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4382" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutWW8_TableNodeInfoInner>"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "</OutWW8_TableNodeInfoInner>"; ::sal::detail
::log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4382" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4383}

4385void MSWordExportBase::OutputStartNode( const SwStartNode & rNode)
4386{

  ww8::WW8TableNodeInfo::Pointer_t pNodeInfo =
      m_pTableInfo->getTableNodeInfo( &rNode );

  if (pNodeInfo)
  {
4393#ifdef DBG_UTIL
      SAL_INFO( "sw.ww8", pNodeInfo->toString())do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << pNodeInfo->toString
()) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), (
"sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4394" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << pNodeInfo->toString()), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 pNodeInfo->toString(); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4394" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << pNodeInfo->toString()) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4394" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << pNodeInfo->toString()), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 pNodeInfo->toString(); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4394" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4395#endif
      const ww8::WW8TableNodeInfo::Inners_t aInners = pNodeInfo->getInners();
      ww8::WW8TableNodeInfo::Inners_t::const_reverse_iterator aIt(aInners.rbegin());
      ww8::WW8TableNodeInfo::Inners_t::const_reverse_iterator aEnd(aInners.rend());
      while (aIt != aEnd)
      {
          ww8::WW8TableNodeInfoInner::Pointer_t pInner = aIt->second;

          AttrOutput().TableNodeInfoInner(pInner);
          ++aIt;
      }
  }
  SAL_INFO( "sw.ww8", "</OutWW8_SwStartNode>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "</OutWW8_SwStartNode>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4407" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutWW8_SwStartNode>"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "</OutWW8_SwStartNode>"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4407" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "</OutWW8_SwStartNode>") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4407" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutWW8_SwStartNode>"), 0); }
 else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "</OutWW8_SwStartNode>"; ::sal::detail::log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4407" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4408}

4410void MSWordExportBase::OutputEndNode( const SwEndNode &rNode )
4411{
4412#ifdef DBG_UTIL
  SAL_INFO( "sw.ww8", "<OutWW8_SwEndNode>" << dbg_out(&rNode))do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "<OutWW8_SwEndNode>"
 << dbg_out(&rNode)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4413" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<OutWW8_SwEndNode>" << dbg_out
(&rNode)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "<OutWW8_SwEndNode>" <<
 dbg_out(&rNode); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4413" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "<OutWW8_SwEndNode>" << dbg_out(&
rNode)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4413" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "<OutWW8_SwEndNode>" << dbg_out
(&rNode)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "<OutWW8_SwEndNode>" <<
 dbg_out(&rNode); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4413" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4414#endif

  ww8::WW8TableNodeInfo::Pointer_t pNodeInfo = m_pTableInfo->getTableNodeInfo( &rNode );

  if (pNodeInfo)
  {
4420#ifdef DBG_UTIL
      SAL_INFO( "sw.ww8", pNodeInfo->toString())do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << pNodeInfo->toString
()) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), (
"sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4421" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << pNodeInfo->toString()), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 pNodeInfo->toString(); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4421" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << pNodeInfo->toString()) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4421" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << pNodeInfo->toString()), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 pNodeInfo->toString(); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4421" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4422#endif
      const ww8::WW8TableNodeInfo::Inners_t aInners = pNodeInfo->getInners();
      for (const auto& rEntry : aInners)
      {
          ww8::WW8TableNodeInfoInner::Pointer_t pInner = rEntry.second;
          AttrOutput().TableNodeInfoInner(pInner);
      }
  }
  SAL_INFO( "sw.ww8", "</OutWW8_SwEndNode>" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "sw.ww8")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "</OutWW8_SwEndNode>"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"
), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4430" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutWW8_SwEndNode>"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</OutWW8_SwEndNode>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4430" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "</OutWW8_SwEndNode>") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4430" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "</OutWW8_SwEndNode>"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "</OutWW8_SwEndNode>"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("sw.ww8"), ("/home/maarten/src/libreoffice/core/sw/source/filter/ww8/wrtww8.cxx"
 ":" "4430" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
4431}

4433const NfKeywordTable & MSWordExportBase::GetNfKeywordTable()
4434{
  if (m_pKeyMap == nullptr)
  {
      m_pKeyMap = std::make_shared<NfKeywordTable>();
      NfKeywordTable & rKeywordTable = *m_pKeyMap;
      rKeywordTable[NF_KEY_D] = "d";
      rKeywordTable[NF_KEY_DD] = "dd";
      rKeywordTable[NF_KEY_DDD] = "ddd";
      rKeywordTable[NF_KEY_DDDD] = "dddd";
      rKeywordTable[NF_KEY_M] = "M";
      rKeywordTable[NF_KEY_MM] = "MM";
      rKeywordTable[NF_KEY_MMM] = "MMM";
      rKeywordTable[NF_KEY_MMMM] = "MMMM";
      rKeywordTable[NF_KEY_NN] = "ddd";
      rKeywordTable[NF_KEY_NNN] = "dddd";
      rKeywordTable[NF_KEY_NNNN] = "dddd";
      rKeywordTable[NF_KEY_YY] = "yy";
      rKeywordTable[NF_KEY_YYYY] = "yyyy";
      rKeywordTable[NF_KEY_H] = "H";
      rKeywordTable[NF_KEY_HH] = "HH";
      rKeywordTable[NF_KEY_MI] = "m";
      rKeywordTable[NF_KEY_MMI] = "mm";
      rKeywordTable[NF_KEY_S] = "s";
      rKeywordTable[NF_KEY_SS] = "ss";
      rKeywordTable[NF_KEY_AMPM] = "AM/PM";
  }

  return *m_pKeyMap;
4462}

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