/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx
Warning:	line 2723, column 1 Potential leak of memory pointed to by 'xStorage.pObj'
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 svxacorr.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 EDITENG_DLLIMPLEMENTATION -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/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/editeng/inc -I /home/maarten/src/libreoffice/core/editeng/source/editeng -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/editeng/generated -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/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/editeng/source/misc/svxacorr.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 <string_view>
22#include <sal/config.h>

24#include <com/sun/star/linguistic2/XSpellChecker1.hpp>
25#include <com/sun/star/embed/XStorage.hpp>
26#include <com/sun/star/io/IOException.hpp>
27#include <com/sun/star/io/XStream.hpp>
28#include <tools/urlobj.hxx>
29#include <i18nlangtag/mslangid.hxx>
30#include <i18nutil/transliteration.hxx>
31#include <sal/log.hxx>
32#include <osl/diagnose.h>
33#include <vcl/svapp.hxx>
34#include <vcl/settings.hxx>
35#include <svl/fstathelper.hxx>
36#include <svl/urihelper.hxx>
37#include <unotools/charclass.hxx>
38#include <com/sun/star/i18n/UnicodeType.hpp>
39#include <unotools/collatorwrapper.hxx>
40#include <com/sun/star/i18n/UnicodeScript.hpp>
41#include <com/sun/star/i18n/OrdinalSuffix.hpp>
42#include <unotools/localedatawrapper.hxx>
43#include <unotools/transliterationwrapper.hxx>
44#include <comphelper/processfactory.hxx>
45#include <comphelper/storagehelper.hxx>
46#include <comphelper/string.hxx>
47#include <editeng/editids.hrc>
48#include <sot/storage.hxx>
49#include <editeng/udlnitem.hxx>
50#include <editeng/wghtitem.hxx>
51#include <editeng/postitem.hxx>
52#include <editeng/crossedoutitem.hxx>
53#include <editeng/escapementitem.hxx>
54#include <editeng/svxacorr.hxx>
55#include <editeng/unolingu.hxx>
56#include <vcl/window.hxx>
57#include <com/sun/star/xml/sax/InputSource.hpp>
58#include <com/sun/star/xml/sax/FastParser.hpp>
59#include <com/sun/star/xml/sax/Writer.hpp>
60#include <com/sun/star/xml/sax/SAXParseException.hpp>
61#include <unotools/streamwrap.hxx>
62#include "SvXMLAutoCorrectImport.hxx"
63#include "SvXMLAutoCorrectExport.hxx"
64#include "SvXMLAutoCorrectTokenHandler.hxx"
65#include <ucbhelper/content.hxx>
66#include <com/sun/star/ucb/ContentCreationException.hpp>
67#include <com/sun/star/ucb/XCommandEnvironment.hpp>
68#include <com/sun/star/ucb/TransferInfo.hpp>
69#include <com/sun/star/ucb/NameClash.hpp>
70#include <tools/diagnose_ex.h>
71#include <xmloff/xmltoken.hxx>
72#include <unordered_map>
73#include <rtl/character.hxx>

75using namespace ::com::sun::star::ucb;
76using namespace ::com::sun::star::uno;
77using namespace ::com::sun::star::xml::sax;
78using namespace ::com::sun::star;
79using namespace ::xmloff::token;
80using namespace ::utl;

82namespace {

84enum class Flags {
  NONE            = 0x00,
  FullStop        = 0x01,
  ExclamationMark = 0x02,
  QuestionMark    = 0x04,
89};

91}

93namespace o3tl {
  template<> struct typed_flags<Flags> : is_typed_flags<Flags, 0x07> {};
95}
96const sal_Unicode cNonBreakingSpace = 0xA0; // UNICODE code for no break space

98const char pXMLImplWrdStt_ExcptLstStr[] = "WordExceptList.xml";
99const char pXMLImplCplStt_ExcptLstStr[] = "SentenceExceptList.xml";
100const char pXMLImplAutocorr_ListStr[]   = "DocumentList.xml";

102const char
  /* also at these beginnings - Brackets and all kinds of begin characters */
  sImplSttSkipChars[] = "\"\'([{\x83\x84\x89\x91\x92\x93\x94",
  /* also at these ends - Brackets and all kinds of begin characters */
  sImplEndSkipChars[] = "\"\')]}\x83\x84\x89\x91\x92\x93\x94";

108static OUString EncryptBlockName_Imp(const OUString& rName);

110static bool NonFieldWordDelim( const sal_Unicode c )
111{
  return ' ' == c || '\t' == c || 0x0a == c ||
          cNonBreakingSpace == c || 0x2011 == c;
114}

116static bool IsWordDelim( const sal_Unicode c )
117{
  return c == 0x1 || NonFieldWordDelim(c);
119}


122static bool IsLowerLetter( sal_Int32 nCharType )
123{
  return CharClass::isLetterType( nCharType ) &&
         ( css::i18n::KCharacterType::LOWER & nCharType);
126}

128static bool IsUpperLetter( sal_Int32 nCharType )
129{
  return CharClass::isLetterType( nCharType ) &&
          ( css::i18n::KCharacterType::UPPER & nCharType);
132}

134static bool lcl_IsUnsupportedUnicodeChar( CharClass const & rCC, const OUString& rTxt,
                                 sal_Int32 nStt, sal_Int32 nEnd )
136{
  for( ; nStt < nEnd; ++nStt )
  {
      css::i18n::UnicodeScript nScript = rCC.getScript( rTxt, nStt );
      switch( nScript )
      {
          case css::i18n::UnicodeScript_kCJKRadicalsSupplement:
          case css::i18n::UnicodeScript_kHangulJamo:
          case css::i18n::UnicodeScript_kCJKSymbolPunctuation:
          case css::i18n::UnicodeScript_kHiragana:
          case css::i18n::UnicodeScript_kKatakana:
          case css::i18n::UnicodeScript_kHangulCompatibilityJamo:
          case css::i18n::UnicodeScript_kEnclosedCJKLetterMonth:
          case css::i18n::UnicodeScript_kCJKCompatibility:
          case css::i18n::UnicodeScript_k_CJKUnifiedIdeographsExtensionA:
          case css::i18n::UnicodeScript_kCJKUnifiedIdeograph:
          case css::i18n::UnicodeScript_kHangulSyllable:
          case css::i18n::UnicodeScript_kCJKCompatibilityIdeograph:
          case css::i18n::UnicodeScript_kHalfwidthFullwidthForm:
              return true;
          default: ; //do nothing
      }
  }
  return false;
160}

162static bool lcl_IsSymbolChar( CharClass const & rCC, const OUString& rTxt,
                                sal_Int32 nStt, sal_Int32 nEnd )
164{
  for( ; nStt < nEnd; ++nStt )
  {
      if( css::i18n::UnicodeType::PRIVATE_USE == rCC.getType( rTxt, nStt ))
          return true;
  }
  return false;
171}

173static bool lcl_IsInAsciiArr( const char* pArr, const sal_Unicode c )
174{
  // tdf#54409 check also typographical quotation marks in the case of skipped ASCII quotation marks
  if ( 0x2018 <= c && c <= 0x201F && (pArr == sImplSttSkipChars || pArr == sImplEndSkipChars) )
      return true;

  bool bRet = false;
  for( ; *pArr; ++pArr )
      if( *pArr == c )
      {
          bRet = true;
          break;
      }
  return bRet;
187}

189SvxAutoCorrDoc::~SvxAutoCorrDoc()
190{
191}

193// Called by the functions:
194//  - FnCapitalStartWord
195//  - FnCapitalStartSentence
196// after the exchange of characters. Then the words, if necessary, can be inserted
197// into the exception list.
198void SvxAutoCorrDoc::SaveCpltSttWord( ACFlags, sal_Int32, const OUString&,
                                      sal_Unicode )
200{
201}

203LanguageType SvxAutoCorrDoc::GetLanguage( sal_Int32 ) const
204{
  return LANGUAGE_SYSTEMLanguageType(0x0000);
206}

208static const LanguageTag& GetAppLang()
209{
  return Application::GetSettings().GetLanguageTag();
211}

213/// Never use an unresolved LANGUAGE_SYSTEM.
214static LanguageType GetDocLanguage( const SvxAutoCorrDoc& rDoc, sal_Int32 nPos )
215{
  LanguageType eLang = rDoc.GetLanguage( nPos );
  if (eLang == LANGUAGE_SYSTEMLanguageType(0x0000))
      eLang = GetAppLang().getLanguageType();     // the current work locale
  return eLang;
220}

222static LocaleDataWrapper& GetLocaleDataWrapper( LanguageType nLang )
223{
  static LocaleDataWrapper aLclDtWrp( GetAppLang() );
  LanguageTag aLcl( nLang );
  const LanguageTag& rLcl = aLclDtWrp.getLoadedLanguageTag();
  if( aLcl != rLcl )
      aLclDtWrp.setLanguageTag( aLcl );
  return aLclDtWrp;
230}
231static TransliterationWrapper& GetIgnoreTranslWrapper()
232{
  static int bIsInit = 0;
  static TransliterationWrapper aWrp( ::comphelper::getProcessComponentContext(),
              TransliterationFlags::IGNORE_KANA |
              TransliterationFlags::IGNORE_WIDTH );
  if( !bIsInit )
  {
      aWrp.loadModuleIfNeeded( GetAppLang().getLanguageType() );
      bIsInit = 1;
  }
  return aWrp;
243}
244static CollatorWrapper& GetCollatorWrapper()
245{
  static CollatorWrapper aCollWrp = [&]()
  {
      CollatorWrapper tmp( ::comphelper::getProcessComponentContext() );
      tmp.loadDefaultCollator( GetAppLang().getLocale(), 0 );
      return tmp;
  }();
  return aCollWrp;
253}

255bool SvxAutoCorrect::IsAutoCorrectChar( sal_Unicode cChar )
256{
  return  cChar == '\0' || cChar == '\t' || cChar == 0x0a ||
          cChar == ' '  || cChar == '\'' || cChar == '\"' ||
          cChar == '*'  || cChar == '_'  || cChar == '%' ||
          cChar == '.'  || cChar == ','  || cChar == ';' ||
          cChar == ':'  || cChar == '?' || cChar == '!' ||
          cChar == '<'  || cChar == '>' ||
          cChar == '/'  || cChar == '-';
264}

266namespace
267{
  bool IsCompoundWordDelimChar(sal_Unicode cChar)
  {
      return  cChar == '-' || SvxAutoCorrect::IsAutoCorrectChar(cChar);
  }
272}

274bool SvxAutoCorrect::NeedsHardspaceAutocorr( sal_Unicode cChar )
275{
  return cChar == '%' || cChar == ';' || cChar == ':'  || cChar == '?' || cChar == '!' ||
      cChar == '/' /*case for the urls exception*/;
278}

280ACFlags SvxAutoCorrect::GetDefaultFlags()
281{
  ACFlags nRet = ACFlags::Autocorrect
                  | ACFlags::CapitalStartSentence
                  | ACFlags::CapitalStartWord
                  | ACFlags::ChgOrdinalNumber
                  | ACFlags::ChgToEnEmDash
                  | ACFlags::AddNonBrkSpace
                  | ACFlags::TransliterateRTL
                  | ACFlags::ChgAngleQuotes
                  | ACFlags::ChgWeightUnderl
                  | ACFlags::SetINetAttr
                  | ACFlags::ChgQuotes
                  | ACFlags::SaveWordCplSttLst
                  | ACFlags::SaveWordWrdSttLst
                  | ACFlags::CorrectCapsLock;
  LanguageType eLang = GetAppLang().getLanguageType();
  if( eLang.anyOf(
      LANGUAGE_ENGLISHLanguageType(0x0009),
      LANGUAGE_ENGLISH_USLanguageType(0x0409),
      LANGUAGE_ENGLISH_UKLanguageType(0x0809),
      LANGUAGE_ENGLISH_AUSLanguageType(0x0C09),
      LANGUAGE_ENGLISH_CANLanguageType(0x1009),
      LANGUAGE_ENGLISH_NZLanguageType(0x1409),
      LANGUAGE_ENGLISH_EIRELanguageType(0x1809),
      LANGUAGE_ENGLISH_SAFRICALanguageType(0x1C09),
      LANGUAGE_ENGLISH_JAMAICALanguageType(0x2009),
      LANGUAGE_ENGLISH_CARIBBEANLanguageType(0x2409)))
      nRet &= ~ACFlags(ACFlags::ChgQuotes|ACFlags::ChgSglQuotes);
  return nRet;
310}

312constexpr sal_Unicode cEmDash = 0x2014;
313constexpr sal_Unicode cEnDash = 0x2013;
314constexpr sal_Unicode cApostrophe = 0x2019;
315constexpr sal_Unicode cLeftDoubleAngleQuote = 0xAB;
316constexpr sal_Unicode cRightDoubleAngleQuote = 0xBB;
317constexpr sal_Unicode cLeftSingleAngleQuote = 0x2039;
318constexpr sal_Unicode cRightSingleAngleQuote = 0x203A;
319// stop characters for searching preceding quotes
320// (the first character is also the opening quote we are looking for)
321const sal_Unicode aStopDoubleAngleQuoteStart[] = { 0x201E, 0x201D, 0x201C, 0 }; // preceding ,,
322const sal_Unicode aStopDoubleAngleQuoteEnd[] = { cRightDoubleAngleQuote, cLeftDoubleAngleQuote, 0x201D, 0x201E, 0 }; // preceding >>
323// preceding << for Romanian, handle also alternative primary closing quotation mark U+201C
324const sal_Unicode aStopDoubleAngleQuoteEndRo[] = { cLeftDoubleAngleQuote, cRightDoubleAngleQuote, 0x201D, 0x201E, 0x201C, 0 };
325const sal_Unicode aStopSingleQuoteEnd[] = { 0x201A, 0x2018, 0x201C, 0x201E, 0 };
326const sal_Unicode aStopSingleQuoteEndRuUa[] = { 0x201E, 0x201C, cRightDoubleAngleQuote, cLeftDoubleAngleQuote, 0 };

328SvxAutoCorrect::SvxAutoCorrect( const OUString& rShareAutocorrFile,
                              const OUString& rUserAutocorrFile )
  : sShareAutoCorrFile( rShareAutocorrFile )
  , sUserAutoCorrFile( rUserAutocorrFile )
  , eCharClassLang( LANGUAGE_DONTKNOWLanguageType(0x03FF) )
  , nFlags(SvxAutoCorrect::GetDefaultFlags())
  , cStartDQuote( 0 )
  , cEndDQuote( 0 )
  , cStartSQuote( 0 )
  , cEndSQuote( 0 )
338{
339}

341SvxAutoCorrect::SvxAutoCorrect( const SvxAutoCorrect& rCpy )
  : sShareAutoCorrFile( rCpy.sShareAutoCorrFile )
  , sUserAutoCorrFile( rCpy.sUserAutoCorrFile )
  , aSwFlags( rCpy.aSwFlags )
  , eCharClassLang(rCpy.eCharClassLang)
  , nFlags( rCpy.nFlags & ~ACFlags(ACFlags::ChgWordLstLoad|ACFlags::CplSttLstLoad|ACFlags::WrdSttLstLoad))
  , cStartDQuote( rCpy.cStartDQuote )
  , cEndDQuote( rCpy.cEndDQuote )
  , cStartSQuote( rCpy.cStartSQuote )
  , cEndSQuote( rCpy.cEndSQuote )
351{
352}


355SvxAutoCorrect::~SvxAutoCorrect()
356{
357}

359void SvxAutoCorrect::GetCharClass_( LanguageType eLang )
360{
  pCharClass.reset( new CharClass( LanguageTag( eLang)) );
  eCharClassLang = eLang;
363}

365void SvxAutoCorrect::SetAutoCorrFlag( ACFlags nFlag, bool bOn )
366{
  ACFlags nOld = nFlags;
  nFlags = bOn ? nFlags | nFlag
               : nFlags & ~nFlag;

  if( !bOn )
  {
      if( (nOld & ACFlags::CapitalStartSentence) != (nFlags & ACFlags::CapitalStartSentence) )
          nFlags &= ~ACFlags::CplSttLstLoad;
      if( (nOld & ACFlags::CapitalStartWord) != (nFlags & ACFlags::CapitalStartWord) )
          nFlags &= ~ACFlags::WrdSttLstLoad;
      if( (nOld & ACFlags::Autocorrect) != (nFlags & ACFlags::Autocorrect) )
          nFlags &= ~ACFlags::ChgWordLstLoad;
  }
380}


383// Correct TWo INitial CApitals
384void SvxAutoCorrect::FnCapitalStartWord( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                                  sal_Int32 nSttPos, sal_Int32 nEndPos,
                                  LanguageType eLang )
387{
  CharClass& rCC = GetCharClass( eLang );

  // Delete all non alphanumeric. Test the characters at the beginning/end of
  // the word ( recognizes: "(min.", "/min.", and so on.)
  for( ; nSttPos < nEndPos; ++nSttPos )
      if( rCC.isLetterNumeric( rTxt, nSttPos ))
          break;
  for( ; nSttPos < nEndPos; --nEndPos )
      if( rCC.isLetterNumeric( rTxt, nEndPos - 1 ))
          break;

  // Is the word a compounded word separated by delimiters?
  // If so, keep track of all delimiters so each constituent
  // word can be checked for two initial capital letters.
  std::deque<sal_Int32> aDelimiters;

  // Always check for two capitals at the beginning
  // of the entire word, so start at nSttPos.
  aDelimiters.push_back(nSttPos);

  // Find all compound word delimiters
  for (sal_Int32 n = nSttPos; n < nEndPos; ++n)
  {
      if (IsCompoundWordDelimChar(rTxt[ n ]))
      {
          aDelimiters.push_back( n + 1 ); // Get position of char after delimiter
      }
  }

  // Decide where to put the terminating delimiter.
  // If the last AutoCorrect char was a newline, then the AutoCorrect
  // char will not be included in rTxt.
  // If the last AutoCorrect char was not a newline, then the AutoCorrect
  // character will be the last character in rTxt.
  if (!IsCompoundWordDelimChar(rTxt[nEndPos-1]))
      aDelimiters.push_back(nEndPos);

  // Iterate through the word and all words that compose it.
  // Two capital letters at the beginning of word?
  for (size_t nI = 0; nI < aDelimiters.size() - 1; ++nI)
  {
      nSttPos = aDelimiters[nI];
      nEndPos = aDelimiters[nI + 1];

      if( nSttPos+2 < nEndPos &&
          IsUpperLetter( rCC.getCharacterType( rTxt, nSttPos )) &&
          IsUpperLetter( rCC.getCharacterType( rTxt, ++nSttPos )) &&
          // Is the third character a lower case
          IsLowerLetter( rCC.getCharacterType( rTxt, nSttPos +1 )) &&
          // Do not replace special attributes
          0x1 != rTxt[ nSttPos ] && 0x2 != rTxt[ nSttPos ])
      {
          // test if the word is in an exception list
          OUString sWord( rTxt.copy( nSttPos - 1, nEndPos - nSttPos + 1 ));
          if( !FindInWrdSttExceptList(eLang, sWord) )
          {
              // Check that word isn't correctly spelt before correcting:
              css::uno::Reference< css::linguistic2::XSpellChecker1 > xSpeller =
                  LinguMgr::GetSpellChecker();
              if( xSpeller->hasLanguage(static_cast<sal_uInt16>(eLang)) )
              {
                  Sequence< css::beans::PropertyValue > aEmptySeq;
                  if (xSpeller->isValid(sWord, static_cast<sal_uInt16>(eLang), aEmptySeq))
                  {
                      return;
                  }
              }
              sal_Unicode cSave = rTxt[ nSttPos ];
              OUString sChar = rCC.lowercase( OUString(cSave) );
              if( sChar[0] != cSave && rDoc.ReplaceRange( nSttPos, 1, sChar ))
              {
                  if( ACFlags::SaveWordWrdSttLst & nFlags )
                      rDoc.SaveCpltSttWord( ACFlags::CapitalStartWord, nSttPos, sWord, cSave );
              }
          }
      }
  }
465}

467// Format ordinal numbers suffixes (1st -> 1^st)
468bool SvxAutoCorrect::FnChgOrdinalNumber(
  SvxAutoCorrDoc& rDoc, const OUString& rTxt,
  sal_Int32 nSttPos, sal_Int32 nEndPos,
  LanguageType eLang)
472{
  // 1st, 2nd, 3rd, 4 - 0th
  // 201th or 201st
  // 12th or 12nd
  bool bChg = false;

  // In some languages ordinal suffixes should never be
  // changed to superscript. Let's break for those languages.
  if (!eLang.anyOf(
       LANGUAGE_SWEDISHLanguageType(0x041D),
       LANGUAGE_SWEDISH_FINLANDLanguageType(0x081D)))
  {
      CharClass& rCC = GetCharClass(eLang);

      for (; nSttPos < nEndPos; ++nSttPos)
          if (!lcl_IsInAsciiArr(sImplSttSkipChars, rTxt[nSttPos]))
              break;
      for (; nSttPos < nEndPos; --nEndPos)
          if (!lcl_IsInAsciiArr(sImplEndSkipChars, rTxt[nEndPos - 1]))
              break;


      // Get the last number in the string to check
      sal_Int32 nNumEnd = nEndPos;
      bool bFoundEnd = false;
      bool isValidNumber = true;
      sal_Int32 i = nEndPos;
      while (i > nSttPos)
      {
          i--;
          bool isDigit = rCC.isDigit(rTxt, i);
          if (bFoundEnd)
              isValidNumber &= (isDigit || !rCC.isLetter(rTxt, i));

          if (isDigit && !bFoundEnd)
          {
              bFoundEnd = true;
              nNumEnd = i;
          }
      }

      if (bFoundEnd && isValidNumber) {
          sal_Int32 nNum = rTxt.copy(nSttPos, nNumEnd - nSttPos + 1).toInt32();

          // Check if the characters after that number correspond to the ordinal suffix
          uno::Reference< i18n::XOrdinalSuffix > xOrdSuffix
              = i18n::OrdinalSuffix::create(comphelper::getProcessComponentContext());

          const uno::Sequence< OUString > aSuffixes = xOrdSuffix->getOrdinalSuffix(nNum, rCC.getLanguageTag().getLocale());
          for (OUString const & sSuffix : aSuffixes)
          {
              OUString sEnd = rTxt.copy(nNumEnd + 1, nEndPos - nNumEnd - 1);

              if (sSuffix == sEnd)
              {
                  // Check if the ordinal suffix has to be set as super script
                  if (rCC.isLetter(sSuffix))
                  {
                      // Do the change
                      SvxEscapementItem aSvxEscapementItem(DFLT_ESC_AUTO_SUPER(13999 +1),
                          DFLT_ESC_PROP58, SID_ATTR_CHAR_ESCAPEMENT( 10000 + 21 ));
                      rDoc.SetAttr(nNumEnd + 1, nEndPos,
                          SID_ATTR_CHAR_ESCAPEMENT( 10000 + 21 ),
                          aSvxEscapementItem);
                      bChg = true;
                  }
              }
          }
      }
  }
  return bChg;
543}

545// Replace dashes
546bool SvxAutoCorrect::FnChgToEnEmDash(
                              SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                              sal_Int32 nSttPos, sal_Int32 nEndPos,
                              LanguageType eLang )
550{
  bool bRet = false;
  CharClass& rCC = GetCharClass( eLang );
  if (eLang == LANGUAGE_SYSTEMLanguageType(0x0000))
      eLang = GetAppLang().getLanguageType();
  bool bAlwaysUseEmDash = (eLang == LANGUAGE_RUSSIANLanguageType(0x0419) || eLang == LANGUAGE_UKRAINIANLanguageType(0x0422));

  // replace " - " or " --" with "enDash"
  if( 1 < nSttPos && 1 <= nEndPos - nSttPos )
  {
      sal_Unicode cCh = rTxt[ nSttPos ];
      if( '-' == cCh )
      {
          if( 1 < nEndPos - nSttPos &&
              ' ' == rTxt[ nSttPos-1 ] &&
              '-' == rTxt[ nSttPos+1 ])
          {
              sal_Int32 n;
              for( n = nSttPos+2; n < nEndPos && lcl_IsInAsciiArr(
                          sImplSttSkipChars,(cCh = rTxt[ n ]));
                      ++n )
                  ;

              // found: " --[<AnySttChars>][A-z0-9]
              if( rCC.isLetterNumeric( OUString(cCh) ) )
              {
                  for( n = nSttPos-1; n && lcl_IsInAsciiArr(
                          sImplEndSkipChars,(cCh = rTxt[ --n ])); )
                      ;

                  // found: "[A-z0-9][<AnyEndChars>] --[<AnySttChars>][A-z0-9]
                  if( rCC.isLetterNumeric( OUString(cCh) ))
                  {
                      rDoc.Delete( nSttPos, nSttPos + 2 );
                      rDoc.Insert( nSttPos, bAlwaysUseEmDash ? OUString(cEmDash) : OUString(cEnDash) );
                      bRet = true;
                  }
              }
          }
      }
      else if( 3 < nSttPos &&
               ' ' == rTxt[ nSttPos-1 ] &&
               '-' == rTxt[ nSttPos-2 ])
      {
          sal_Int32 n, nLen = 1, nTmpPos = nSttPos - 2;
          if( '-' == ( cCh = rTxt[ nTmpPos-1 ]) )
          {
              --nTmpPos;
              ++nLen;
              cCh = rTxt[ nTmpPos-1 ];
          }
          if( ' ' == cCh )
          {
              for( n = nSttPos; n < nEndPos && lcl_IsInAsciiArr(
                          sImplSttSkipChars,(cCh = rTxt[ n ]));
                      ++n )
                  ;

              // found: " - [<AnySttChars>][A-z0-9]
              if( rCC.isLetterNumeric( OUString(cCh) ) )
              {
                  cCh = ' ';
                  for( n = nTmpPos-1; n && lcl_IsInAsciiArr(
                          sImplEndSkipChars,(cCh = rTxt[ --n ])); )
                          ;
                  // found: "[A-z0-9][<AnyEndChars>] - [<AnySttChars>][A-z0-9]
                  if( rCC.isLetterNumeric( OUString(cCh) ))
                  {
                      rDoc.Delete( nTmpPos, nTmpPos + nLen );
                      rDoc.Insert( nTmpPos, bAlwaysUseEmDash ? OUString(cEmDash) : OUString(cEnDash) );
                      bRet = true;
                  }
              }
          }
      }
  }

  // Replace [A-z0-9]--[A-z0-9] double dash with "emDash" or "enDash"
  // [0-9]--[0-9] double dash always replaced with "enDash"
  // Finnish and Hungarian use enDash instead of emDash.
  bool bEnDash = (eLang == LANGUAGE_HUNGARIANLanguageType(0x040E) || eLang == LANGUAGE_FINNISHLanguageType(0x040B));
  if( 4 <= nEndPos - nSttPos )
  {
      OUString sTmp( rTxt.copy( nSttPos, nEndPos - nSttPos ) );
      sal_Int32 nFndPos = sTmp.indexOf("--");
      if( nFndPos != -1 && nFndPos &&
          nFndPos + 2 < sTmp.getLength() &&
          ( rCC.isLetterNumeric( sTmp, nFndPos - 1 ) ||
            lcl_IsInAsciiArr( sImplEndSkipChars, rTxt[ nFndPos - 1 ] )) &&
          ( rCC.isLetterNumeric( sTmp, nFndPos + 2 ) ||
          lcl_IsInAsciiArr( sImplSttSkipChars, rTxt[ nFndPos + 2 ] )))
      {
          nSttPos = nSttPos + nFndPos;
          rDoc.Delete( nSttPos, nSttPos + 2 );
          rDoc.Insert( nSttPos, (bEnDash || (rCC.isDigit( sTmp, nFndPos - 1 ) &&
              rCC.isDigit( sTmp, nFndPos + 2 )) ? OUString(cEnDash) : OUString(cEmDash)) );
          bRet = true;
      }
  }
  return bRet;
650}

652// Add non-breaking space before specific punctuation marks in French text
653bool SvxAutoCorrect::FnAddNonBrkSpace(
                              SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                              sal_Int32 nEndPos,
                              LanguageType eLang, bool& io_bNbspRunNext )
657{
  bool bRet = false;

  CharClass& rCC = GetCharClass( eLang );

  if ( rCC.getLanguageTag().getLanguage() == "fr" )
  {
      bool bFrCA = (rCC.getLanguageTag().getCountry() == "CA");
      OUString allChars = ":;?!%";
      OUString chars( allChars );
      if ( bFrCA )
          chars = ":";

      sal_Unicode cChar = rTxt[ nEndPos ];
      bool bHasSpace = chars.indexOf( cChar ) != -1;
      bool bIsSpecial = allChars.indexOf( cChar ) != -1;
      if ( bIsSpecial )
      {
          // Get the last word delimiter position
          sal_Int32 nSttWdPos = nEndPos;
          bool bWasWordDelim = false;
          while( nSttWdPos )
          {
              bWasWordDelim = IsWordDelim( rTxt[ --nSttWdPos ]);
              if (bWasWordDelim)
                  break;
          }

          //See if the text is the start of a protocol string, e.g. have text of
          //"http" see if it is the start of "http:" and if so leave it alone
          sal_Int32 nIndex = nSttWdPos + (bWasWordDelim ? 1 : 0);
          sal_Int32 nProtocolLen = nEndPos - nSttWdPos + 1;
          if (nIndex + nProtocolLen <= rTxt.getLength())
          {
              if (INetURLObject::CompareProtocolScheme(rTxt.copy(nIndex, nProtocolLen)) != INetProtocol::NotValid)
                  return false;
          }

          // Check the presence of "://" in the word
          sal_Int32 nStrPos = rTxt.indexOf( "://", nSttWdPos + 1 );
          if ( nStrPos == -1 && nEndPos > 0 )
          {
              // Check the previous char
              sal_Unicode cPrevChar = rTxt[ nEndPos - 1 ];
              if ( ( chars.indexOf( cPrevChar ) == -1 ) && cPrevChar != '\t' )
              {
                  // Remove any previous normal space
                  sal_Int32 nPos = nEndPos - 1;
                  while ( cPrevChar == ' ' || cPrevChar == cNonBreakingSpace )
                  {
                      if ( nPos == 0 ) break;
                      nPos--;
                      cPrevChar = rTxt[ nPos ];
                  }

                  nPos++;
                  if ( nEndPos - nPos > 0 )
                      rDoc.Delete( nPos, nEndPos );

                  // Add the non-breaking space at the end pos
                  if ( bHasSpace )
                      rDoc.Insert( nPos, OUString(cNonBreakingSpace) );
                  io_bNbspRunNext = true;
                  bRet = true;
              }
              else if ( chars.indexOf( cPrevChar ) != -1 )
                  io_bNbspRunNext = true;
          }
      }
      else if ( cChar == '/' && nEndPos > 1 && rTxt.getLength() > (nEndPos - 1) )
      {
          // Remove the hardspace right before to avoid formatting URLs
          sal_Unicode cPrevChar = rTxt[ nEndPos - 1 ];
          sal_Unicode cMaybeSpaceChar = rTxt[ nEndPos - 2 ];
          if ( cPrevChar == ':' && cMaybeSpaceChar == cNonBreakingSpace )
          {
              rDoc.Delete( nEndPos - 2, nEndPos - 1 );
              bRet = true;
          }
      }
  }

  return bRet;
740}

742// URL recognition
743bool SvxAutoCorrect::FnSetINetAttr( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                                  sal_Int32 nSttPos, sal_Int32 nEndPos,
                                  LanguageType eLang )
746{
  OUString sURL( URIHelper::FindFirstURLInText( rTxt, nSttPos, nEndPos,
                                              GetCharClass( eLang ) ));
  bool bRet = !sURL.isEmpty();
  if( bRet )          // so, set attribute:
      rDoc.SetINetAttr( nSttPos, nEndPos, sURL );
  return bRet;
753}

755// Automatic *bold*, /italic/, -strikeout- and _underline_
756bool SvxAutoCorrect::FnChgWeightUnderl( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                                      sal_Int32 nEndPos )
758{
  // Condition:
  //  at the beginning:   _, *, / or ~ after Space with the following !Space
  //  at the end:         _, *, / or ~ before Space (word delimiter?)

  sal_Unicode cInsChar = rTxt[ nEndPos ];  // underline, bold, italic or strikeout
  if( ++nEndPos != rTxt.getLength() &&
      !IsWordDelim( rTxt[ nEndPos ] ) )
      return false;

  --nEndPos;

  bool bAlphaNum = false;
  sal_Int32 nPos = nEndPos;
  sal_Int32  nFndPos = -1;
  CharClass& rCC = GetCharClass( LANGUAGE_SYSTEMLanguageType(0x0000) );

  while( nPos )
  {
      switch( sal_Unicode c = rTxt[ --nPos ] )
      {
      case '_':
      case '-':
      case '/':
      case '*':
          if( c == cInsChar )
          {
              if( bAlphaNum && nPos+1 < nEndPos && ( !nPos ||
                  IsWordDelim( rTxt[ nPos-1 ])) &&
                  !IsWordDelim( rTxt[ nPos+1 ]))
                      nFndPos = nPos;
              else
                  // Condition is not satisfied, so cancel
                  nFndPos = -1;
              nPos = 0;
          }
          break;
      default:
          if( !bAlphaNum )
              bAlphaNum = rCC.isLetterNumeric( rTxt, nPos );
      }
  }

  if( -1 != nFndPos )
  {
      // first delete the Character at the end - this allows insertion
      // of an empty hint in SetAttr which would be removed by Delete
      // (fdo#62536, AUTOFMT in Writer)
      rDoc.Delete( nEndPos, nEndPos + 1 );
      rDoc.Delete( nFndPos, nFndPos + 1 );
      // Span the Attribute over the area
      // the end.
      if( '*' == cInsChar )           // Bold
      {
          SvxWeightItem aSvxWeightItem( WEIGHT_BOLD, SID_ATTR_CHAR_WEIGHT( 10000 + 9 ) );
          rDoc.SetAttr( nFndPos, nEndPos - 1,
                        SID_ATTR_CHAR_WEIGHT( 10000 + 9 ),
                        aSvxWeightItem);
      }
      else if( '/' == cInsChar )           // Italic
      {
          SvxPostureItem aSvxPostureItem( ITALIC_NORMAL, SID_ATTR_CHAR_POSTURE( 10000 + 8 ) );
          rDoc.SetAttr( nFndPos, nEndPos - 1,
                        SID_ATTR_CHAR_POSTURE( 10000 + 8 ),
                        aSvxPostureItem);
      }
      else if( '-' == cInsChar )           // Strikeout
      {
          SvxCrossedOutItem aSvxCrossedOutItem( STRIKEOUT_SINGLE, SID_ATTR_CHAR_STRIKEOUT( 10000 + 13 ) );
          rDoc.SetAttr( nFndPos, nEndPos - 1,
                        SID_ATTR_CHAR_STRIKEOUT( 10000 + 13 ),
                        aSvxCrossedOutItem);
      }
      else                            // Underline
      {
          SvxUnderlineItem aSvxUnderlineItem( LINESTYLE_SINGLE, SID_ATTR_CHAR_UNDERLINE( 10000 + 14 ) );
          rDoc.SetAttr( nFndPos, nEndPos - 1,
                        SID_ATTR_CHAR_UNDERLINE( 10000 + 14 ),
                        aSvxUnderlineItem);
      }
    }

  return -1 != nFndPos;
841}

843// Capitalize first letter of every sentence
844void SvxAutoCorrect::FnCapitalStartSentence( SvxAutoCorrDoc& rDoc,
                                  const OUString& rTxt, bool bNormalPos,
                                  sal_Int32 nSttPos, sal_Int32 nEndPos,
                                  LanguageType eLang )
848{

  if( rTxt.isEmpty() || nEndPos <= nSttPos )
      return;

  CharClass& rCC = GetCharClass( eLang );
  OUString aText( rTxt );
  const sal_Unicode *pStart = aText.getStr(),
                    *pStr = pStart + nEndPos,
                    *pWordStt = nullptr,
                    *pDelim = nullptr;

  bool bAtStart = false;
  do {
      --pStr;
      if (rCC.isLetter(aText, pStr - pStart))
      {
          if( !pWordStt )
              pDelim = pStr+1;
          pWordStt = pStr;
      }
      else if (pWordStt && !rCC.isDigit(aText, pStr - pStart))
      {
          if( (lcl_IsInAsciiArr( "-'", *pStr ) || *pStr == cApostrophe) && // These characters are allowed in words
              pWordStt - 1 == pStr &&
              // Installation at beginning of paragraph. Replaced < by <= (#i38971#)
              (pStart + 1) <= pStr &&
              rCC.isLetter(aText, pStr-1 - pStart))
              pWordStt = --pStr;
          else
              break;
      }
      bAtStart = (pStart == pStr);
  } while( !bAtStart );

  if (!pWordStt)
      return;    // no character to be replaced


  if (rCC.isDigit(aText, pStr - pStart))
      return; // already ok

  if (IsUpperLetter(rCC.getCharacterType(aText, pWordStt - pStart)))
      return; // already ok

  //See if the text is the start of a protocol string, e.g. have text of
  //"http" see if it is the start of "http:" and if so leave it alone
  sal_Int32 nIndex = pWordStt - pStart;
  sal_Int32 nProtocolLen = pDelim - pWordStt + 1;
  if (nIndex + nProtocolLen <= rTxt.getLength())
  {
      if (INetURLObject::CompareProtocolScheme(rTxt.copy(nIndex, nProtocolLen)) != INetProtocol::NotValid)
          return; // already ok
  }

  if (0x1 == *pWordStt || 0x2 == *pWordStt)
      return; // already ok

  // Only capitalize, if string before specified characters is long enough
  if( *pDelim && 2 >= pDelim - pWordStt &&
      lcl_IsInAsciiArr( ".-)>", *pDelim ) )
      return;

  // tdf#59666 don't capitalize single Greek letters (except in Greek texts)
  if ( 1 == pDelim - pWordStt && 0x03B1 <= *pWordStt && *pWordStt <= 0x03C9 && eLang != LANGUAGE_GREEKLanguageType(0x0408) )
      return;

  if( !bAtStart ) // Still no beginning of a paragraph?
  {
      if (NonFieldWordDelim(*pStr))
      {
          for (;;)
          {
              bAtStart = (pStart == pStr--);
              if (bAtStart || !NonFieldWordDelim(*pStr))
                  break;
          }
      }
      // Asian full stop, full width full stop, full width exclamation mark
      // and full width question marks are treated as word delimiters
      else if ( 0x3002 != *pStr && 0xFF0E != *pStr && 0xFF01 != *pStr &&
                0xFF1F != *pStr )
          return; // no valid separator -> no replacement
  }

  // No replacement for words in TWo INitial CApitals or sMALL iNITIAL list
  if (FindInWrdSttExceptList(eLang, OUString(pWordStt, pDelim - pWordStt)))
      return;

  if( bAtStart )  // at the beginning of a paragraph?
  {
      // Check out the previous paragraph, if it exists.
      // If so, then check to paragraph separator at the end.
      OUString const*const pPrevPara = rDoc.GetPrevPara(bNormalPos);
      if (!pPrevPara)
      {
          // valid separator -> replace
          OUString sChar( *pWordStt );
          sChar = rCC.titlecase(sChar); //see fdo#56740
          if (!comphelper::string::equals(sChar, *pWordStt))
             rDoc.ReplaceRange( pWordStt - pStart, 1, sChar );
          return;
      }

      aText = *pPrevPara;
      bAtStart = false;
      pStart = aText.getStr();
      pStr = pStart + aText.getLength();

      do {            // overwrite all blanks
          --pStr;
          if (!NonFieldWordDelim(*pStr))
              break;
          bAtStart = (pStart == pStr);
      } while( !bAtStart );

      if( bAtStart )
          return;  // no valid separator -> no replacement
  }

  // Found [ \t]+[A-Z0-9]+ until here. Test now on the paragraph separator.
  // all three can happen, but not more than once!
  const sal_Unicode* pExceptStt = nullptr;
  bool bContinue = true;
  Flags nFlag = Flags::NONE;
  do
  {
      switch (*pStr)
      {
          // Western and Asian full stop
          case '.':
          case 0x3002:
          case 0xFF0E:
          {
              if (pStr >= pStart + 2 && *(pStr - 2) == '.')
              {
                  //e.g. text "f.o.o. word": Now currently considering
                  //capitalizing word but second last character of
                  //previous word is a .  So probably last word is an
                  //anagram that ends in . and not truly the end of a
                  //previous sentence, so don't autocapitalize this word
                  return;
              }
              if (nFlag & Flags::FullStop)
                  return; // no valid separator -> no replacement
              nFlag |= Flags::FullStop;
              pExceptStt = pStr;
          }
          break;
          case '!':
          case 0xFF01:
          {
              if (nFlag & Flags::ExclamationMark)
                  return; // no valid separator -> no replacement
              nFlag |= Flags::ExclamationMark;
          }
          break;
          case '?':
          case 0xFF1F:
          {
              if (nFlag & Flags::QuestionMark)
                  return; // no valid separator -> no replacement
              nFlag |= Flags::QuestionMark;
          }
          break;
          default:
              if (nFlag == Flags::NONE)
                  return; // no valid separator -> no replacement
              else
                  bContinue = false;
              break;
      }

      if (bContinue && pStr-- == pStart)
      {
          return; // no valid separator -> no replacement
      }
  } while (bContinue);
  if (Flags::FullStop != nFlag)
      pExceptStt = nullptr;

  // Only capitalize, if string is long enough
  if( 2 > ( pStr - pStart ) )
      return;

  if (!rCC.isLetterNumeric(aText, pStr-- - pStart))
  {
      bool bValid = false, bAlphaFnd = false;
      const sal_Unicode* pTmpStr = pStr;
      while( !bValid )
      {
          if( rCC.isDigit( aText, pTmpStr - pStart ) )
          {
              bValid = true;
              pStr = pTmpStr - 1;
          }
          else if( rCC.isLetter( aText, pTmpStr - pStart ) )
          {
              if( bAlphaFnd )
              {
                  bValid = true;
                  pStr = pTmpStr;
              }
              else
                  bAlphaFnd = true;
          }
          else if (bAlphaFnd || NonFieldWordDelim(*pTmpStr))
              break;

          if( pTmpStr == pStart )
              break;

          --pTmpStr;
      }

      if( !bValid )
          return;       // no valid separator -> no replacement
  }

  bool bNumericOnly = '0' <= *(pStr+1) && *(pStr+1) <= '9';

  // Search for the beginning of the word
  while (!NonFieldWordDelim(*pStr))
  {
      if( bNumericOnly && rCC.isLetter( aText, pStr - pStart ) )
          bNumericOnly = false;

      if( pStart == pStr )
          break;

      --pStr;
  }

  if( bNumericOnly )      // consists of only numbers, then not
      return;

  if (NonFieldWordDelim(*pStr))
      ++pStr;

  OUString sWord;

  // check on the basis of the exception list
  if( pExceptStt )
  {
      sWord = OUString(pStr, pExceptStt - pStr + 1);
      if( FindInCplSttExceptList(eLang, sWord) )
          return;

      // Delete all non alphanumeric. Test the characters at the
      // beginning/end of the word ( recognizes: "(min.", "/min.", and so on.)
      OUString sTmp( sWord );
      while( !sTmp.isEmpty() &&
              !rCC.isLetterNumeric( sTmp, 0 ) )
          sTmp = sTmp.copy(1);

      // Remove all non alphanumeric characters towards the end up until
      // the last one.
      sal_Int32 nLen = sTmp.getLength();
      while( nLen && !rCC.isLetterNumeric( sTmp, nLen-1 ) )
          --nLen;
      if( nLen + 1 < sTmp.getLength() )
          sTmp = sTmp.copy( 0, nLen + 1 );

      if( !sTmp.isEmpty() && sTmp.getLength() != sWord.getLength() &&
          FindInCplSttExceptList(eLang, sTmp))
          return;

      if(FindInCplSttExceptList(eLang, sWord, true))
          return;
  }

  // Ok, then replace
  sal_Unicode cSave = *pWordStt;
  nSttPos = pWordStt - rTxt.getStr();
  OUString sChar = rCC.titlecase(OUString(cSave)); //see fdo#56740
  bool bRet = sChar[0] != cSave && rDoc.ReplaceRange( nSttPos, 1, sChar );

  // Perhaps someone wants to have the word
  if( bRet && ACFlags::SaveWordCplSttLst & nFlags )
      rDoc.SaveCpltSttWord( ACFlags::CapitalStartSentence, nSttPos, sWord, cSave );
1128}

1130// Correct accidental use of cAPS LOCK key
1131bool SvxAutoCorrect::FnCorrectCapsLock( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                                      sal_Int32 nSttPos, sal_Int32 nEndPos,
                                      LanguageType eLang )
1134{
  if (nEndPos - nSttPos < 2)
      // string must be at least 2-character long.
      return false;

  CharClass& rCC = GetCharClass( eLang );

  // Check the first 2 letters.
  if ( !IsLowerLetter(rCC.getCharacterType(rTxt, nSttPos)) )
      return false;

  if ( !IsUpperLetter(rCC.getCharacterType(rTxt, nSttPos+1)) )
      return false;

  OUStringBuffer aConverted;
  aConverted.append( rCC.uppercase(OUString(rTxt[nSttPos])) );
  aConverted.append( rCC.lowercase(OUString(rTxt[nSttPos+1])) );

  // No replacement for words in TWo INitial CApitals or sMALL iNITIAL list
  if (FindInWrdSttExceptList(eLang, rTxt.copy(nSttPos, nEndPos - nSttPos)))
      return false;

  for( sal_Int32 i = nSttPos+2; i < nEndPos; ++i )
  {
      if ( IsLowerLetter(rCC.getCharacterType(rTxt, i)) )
          // A lowercase letter disqualifies the whole text.
          return false;

      if ( IsUpperLetter(rCC.getCharacterType(rTxt, i)) )
          // Another uppercase letter.  Convert it.
          aConverted.append( rCC.lowercase(OUString(rTxt[i])) );
      else
          // This is not an alphabetic letter.  Leave it as-is.
          aConverted.append( rTxt[i] );
  }

  // Replace the word.
  rDoc.Delete(nSttPos, nEndPos);
  rDoc.Insert(nSttPos, aConverted.makeStringAndClear());

  return true;
1175}


1178sal_Unicode SvxAutoCorrect::GetQuote( sal_Unicode cInsChar, bool bSttQuote,
                                      LanguageType eLang ) const
1180{
  sal_Unicode cRet = bSttQuote ? ( '\"' == cInsChar
                                  ? GetStartDoubleQuote()
                                  : GetStartSingleQuote() )
                                 : ( '\"' == cInsChar
                                  ? GetEndDoubleQuote()
                                  : GetEndSingleQuote() );
  if( !cRet )
  {
      // then through the Language find the right character
      if( LANGUAGE_NONELanguageType(0x00FF) == eLang )
          cRet = cInsChar;
      else
      {
          LocaleDataWrapper& rLcl = GetLocaleDataWrapper( eLang );
          OUString sRet( bSttQuote
                          ? ( '\"' == cInsChar
                              ? rLcl.getDoubleQuotationMarkStart()
                              : rLcl.getQuotationMarkStart() )
                          : ( '\"' == cInsChar
                              ? rLcl.getDoubleQuotationMarkEnd()
                              : rLcl.getQuotationMarkEnd() ));
          cRet = !sRet.isEmpty() ? sRet[0] : cInsChar;
      }
  }
  return cRet;
1206}

1208void SvxAutoCorrect::InsertQuote( SvxAutoCorrDoc& rDoc, sal_Int32 nInsPos,
                                  sal_Unicode cInsChar, bool bSttQuote,
                                  bool bIns, LanguageType eLang, ACQuotes eType ) const
1211{
  sal_Unicode cRet;

  if ( eType == ACQuotes::DoubleAngleQuote )
  {
      bool bSwiss = eLang == LANGUAGE_FRENCH_SWISSLanguageType(0x100C);
      // pressing " inside a quotation -> use second level angle quotes
      bool bLeftQuote = '\"' == cInsChar &&
              // start position and Romanian OR
              // not start position and Hungarian
              bSttQuote == (eLang != LANGUAGE_HUNGARIANLanguageType(0x040E));
      cRet = ( '<' == cInsChar || bLeftQuote )
              ? ( bSwiss ? cLeftSingleAngleQuote : cLeftDoubleAngleQuote )
              : ( bSwiss ? cRightSingleAngleQuote : cRightDoubleAngleQuote );
  }
  else if ( eType == ACQuotes::UseApostrophe )
      cRet = cApostrophe;
  else
      cRet = GetQuote( cInsChar, bSttQuote, eLang );

  OUString sChg( cInsChar );
  if( bIns )
      rDoc.Insert( nInsPos, sChg );
  else
      rDoc.Replace( nInsPos, sChg );

  sChg = OUString(cRet);

  if( eType == ACQuotes::NonBreakingSpace )
  {
      if( rDoc.Insert( bSttQuote ? nInsPos+1 : nInsPos, OUStringChar(cNonBreakingSpace) ))
      {
          if( !bSttQuote )
              ++nInsPos;
      }
  }
  else if( eType == ACQuotes::DoubleAngleQuote && cInsChar != '\"' )
  {
      rDoc.Delete( nInsPos-1, nInsPos);
      --nInsPos;
  }

  rDoc.Replace( nInsPos, sChg );

  // i' -> I' in English (last step for the Undo)
  if( eType == ACQuotes::CapitalizeIAm )
      rDoc.Replace( nInsPos-1, "I" );
1258}

1260OUString SvxAutoCorrect::GetQuote( SvxAutoCorrDoc const & rDoc, sal_Int32 nInsPos,
                              sal_Unicode cInsChar, bool bSttQuote )
1262{
  const LanguageType eLang = GetDocLanguage( rDoc, nInsPos );
  sal_Unicode cRet = GetQuote( cInsChar, bSttQuote, eLang );

  OUString sRet(cRet);

  if( '\"' == cInsChar )
  {
      if (primary(eLang) == primary(LANGUAGE_FRENCHLanguageType(0x040C)) && eLang != LANGUAGE_FRENCH_SWISSLanguageType(0x100C))
      {
          if( bSttQuote )
              sRet += " ";
          else
              sRet = " " + sRet;
      }
  }
  return sRet;
1279}

1281// search preceding opening quote in the paragraph before the insert position
1282static bool lcl_HasPrecedingChar( const OUString& rTxt, sal_Int32 nPos,
              const sal_Unicode sPrecedingChar, const sal_Unicode* aStopChars )
1284{
  sal_Unicode cTmpChar;

  do {
      cTmpChar = rTxt[ --nPos ];
      if ( cTmpChar == sPrecedingChar )
          return true;

      for ( const sal_Unicode* pCh = aStopChars; *pCh; ++pCh )
          if ( cTmpChar == *pCh )
              return false;

  } while ( nPos > 0 );

  return false;
1299}

1301// WARNING: rText may become invalid, see comment below
1302void SvxAutoCorrect::DoAutoCorrect( SvxAutoCorrDoc& rDoc, const OUString& rTxt,
                                  sal_Int32 nInsPos, sal_Unicode cChar,
                                  bool bInsert, bool& io_bNbspRunNext, vcl::Window const * pFrameWin )
1305{
  bool bIsNextRun = io_bNbspRunNext;
  io_bNbspRunNext = false;  // if it was set, then it has to be turned off

  do{                                 // only for middle check loop !!
      if( cChar )
      {
          // Prevent double space
          if( nInsPos && ' ' == cChar &&
              IsAutoCorrFlag( ACFlags::IgnoreDoubleSpace ) &&
              ' ' == rTxt[ nInsPos - 1 ])
          {
              break;
          }

          bool bSingle = '\'' == cChar;
          bool bIsReplaceQuote =
                      (IsAutoCorrFlag( ACFlags::ChgQuotes ) && ('\"' == cChar )) ||
                      (IsAutoCorrFlag( ACFlags::ChgSglQuotes ) && bSingle );
          if( bIsReplaceQuote )
          {
              bool bSttQuote = !nInsPos;
              ACQuotes eType = ACQuotes::NONE;
              const LanguageType eLang = GetDocLanguage( rDoc, nInsPos );
              if (!bSttQuote)
              {
                  sal_Unicode cPrev = rTxt[ nInsPos-1 ];
                  bSttQuote = NonFieldWordDelim(cPrev) ||
                      lcl_IsInAsciiArr( "([{", cPrev ) ||
                      ( cEmDash == cPrev ) ||
                      ( cEnDash == cPrev );
                  // tdf#38394 use opening quotation mark << in French l'<<word>>
                  if ( !bSingle && !bSttQuote && cPrev == cApostrophe &&
                      primary(eLang) == primary(LANGUAGE_FRENCHLanguageType(0x040C)) &&
                      ( ( ( nInsPos == 2 || ( nInsPos > 2 && IsWordDelim( rTxt[ nInsPos-3 ] ) ) ) &&
                             // abbreviated form of ce, de, je, la, le, ne, me, te, se or si
                             OUString("cdjlnmtsCDJLNMTS").indexOf( rTxt[ nInsPos-2 ] ) > -1 ) ||
                        ( ( nInsPos == 3 || (nInsPos > 3 && IsWordDelim( rTxt[ nInsPos-4 ] ) ) ) &&
                             // abbreviated form of que
                             ( rTxt[ nInsPos-2 ] == 'u' || rTxt[ nInsPos-2 ] == 'U' ) &&
                             ( rTxt[ nInsPos-3 ] == 'q' || rTxt[ nInsPos-3 ] == 'Q' ) ) ) )
                  {
                      bSttQuote = true;
                  }
                  // tdf#108423 for capitalization of English i'm
                  else if ( bSingle && ( cPrev == 'i' ) &&
                      primary(eLang) == primary(LANGUAGE_ENGLISHLanguageType(0x0009)) &&
                      ( nInsPos == 1 || IsWordDelim( rTxt[ nInsPos-2 ] ) ) )
                  {
                      eType = ACQuotes::CapitalizeIAm;
                  }
                  // tdf#133524 support >>Hungarian<< and <<Romanian>> secondary level quotations
                  else if ( !bSingle && nInsPos &&
                      ( ( eLang == LANGUAGE_HUNGARIANLanguageType(0x040E) &&
                          lcl_HasPrecedingChar( rTxt, nInsPos,
                              bSttQuote ? aStopDoubleAngleQuoteStart[0] : aStopDoubleAngleQuoteEnd[0],
                              bSttQuote ? aStopDoubleAngleQuoteStart + 1 : aStopDoubleAngleQuoteEnd + 1 ) ) ||
                        ( eLang.anyOf(
                              LANGUAGE_ROMANIANLanguageType(0x0418),
                              LANGUAGE_ROMANIAN_MOLDOVALanguageType(0x0818) ) &&
                          lcl_HasPrecedingChar( rTxt, nInsPos,
                              bSttQuote ? aStopDoubleAngleQuoteStart[0] : aStopDoubleAngleQuoteEndRo[0],
                              bSttQuote ? aStopDoubleAngleQuoteStart + 1 : aStopDoubleAngleQuoteEndRo + 1 ) ) ) )
                  {
                      LocaleDataWrapper& rLcl = GetLocaleDataWrapper( eLang );
                      // only if the opening double quotation mark is the default one
                      if ( rLcl.getDoubleQuotationMarkStart() == OUStringChar(aStopDoubleAngleQuoteStart[0]) )
                          eType = ACQuotes::DoubleAngleQuote;
                  }
                  else if ( bSingle && nInsPos && !bSttQuote &&
                      // tdf#128860 use apostrophe outside of second level quotation in Czech, German, Icelandic,
                      // Slovak and Slovenian instead of the – in this case, bad – closing quotation mark U+2018.
                      // tdf#123786 the same for Russian and Ukrainian
                      ( ( eLang.anyOf (
                               LANGUAGE_CZECHLanguageType(0x0405),
                               LANGUAGE_GERMANLanguageType(0x0407),
                               LANGUAGE_GERMAN_SWISSLanguageType(0x0807),
                               LANGUAGE_GERMAN_AUSTRIANLanguageType(0x0C07),
                               LANGUAGE_GERMAN_LUXEMBOURGLanguageType(0x1007),
                               LANGUAGE_GERMAN_LIECHTENSTEINLanguageType(0x1407),
                               LANGUAGE_ICELANDICLanguageType(0x040F),
                               LANGUAGE_SLOVAKLanguageType(0x041B),
                               LANGUAGE_SLOVENIANLanguageType(0x0424) ) &&
                          !lcl_HasPrecedingChar( rTxt, nInsPos, aStopSingleQuoteEnd[0],  aStopSingleQuoteEnd + 1 ) ) ||
                        ( eLang.anyOf (
                               LANGUAGE_RUSSIANLanguageType(0x0419),
                               LANGUAGE_UKRAINIANLanguageType(0x0422) ) &&
                          !lcl_HasPrecedingChar( rTxt, nInsPos, aStopSingleQuoteEndRuUa[0],  aStopSingleQuoteEndRuUa + 1 ) ) ) )
                  {
                      LocaleDataWrapper& rLcl = GetLocaleDataWrapper( eLang );
                      CharClass& rCC = GetCharClass( eLang );
                      if ( ( rLcl.getQuotationMarkStart() == OUStringChar(aStopSingleQuoteEnd[0]) ||
                           rLcl.getQuotationMarkStart() == OUStringChar(aStopSingleQuoteEndRuUa[0]) ) &&
                           // use apostrophe only after letters, not after digits or punctuation
                           rCC.isLetter(rTxt, nInsPos-1) )
                      {
                          eType = ACQuotes::UseApostrophe;
                      }
                  }
              }

              if ( eType == ACQuotes::NONE && !bSingle &&
                  ( primary(eLang) == primary(LANGUAGE_FRENCHLanguageType(0x040C)) && eLang != LANGUAGE_FRENCH_SWISSLanguageType(0x100C) ) )
                  eType = ACQuotes::NonBreakingSpace;

              InsertQuote( rDoc, nInsPos, cChar, bSttQuote, bInsert, eLang, eType );
              break;
          }
          // tdf#133524 change "<<" and ">>" to double angle quotation marks
          else if ( IsAutoCorrFlag( ACFlags::ChgQuotes ) &&
              IsAutoCorrFlag( ACFlags::ChgAngleQuotes ) &&
              ('<' == cChar || '>' == cChar) &&
              nInsPos > 0 && cChar == rTxt[ nInsPos-1 ] )
          {
              const LanguageType eLang = GetDocLanguage( rDoc, nInsPos );
              if ( eLang.anyOf(
                      LANGUAGE_CATALANLanguageType(0x0403),              // primary level
                      LANGUAGE_CATALAN_VALENCIANLanguageType(0x0803),    // primary level
                      LANGUAGE_FINNISHLanguageType(0x040B),              // alternative primary level
                      LANGUAGE_FRENCH_SWISSLanguageType(0x100C),         // second level
                      LANGUAGE_GALICIANLanguageType(0x0456),             // primary level
                      LANGUAGE_HUNGARIANLanguageType(0x040E),            // second level
                      LANGUAGE_POLISHLanguageType(0x0415),               // second level
                      LANGUAGE_PORTUGUESELanguageType(0x0816),           // primary level
                      LANGUAGE_PORTUGUESE_BRAZILIANLanguageType(0x0416), // primary level
                      LANGUAGE_ROMANIANLanguageType(0x0418),             // second level
                      LANGUAGE_ROMANIAN_MOLDOVALanguageType(0x0818),     // second level
                      LANGUAGE_SWEDISHLanguageType(0x041D),              // alternative primary level
                      LANGUAGE_SWEDISH_FINLANDLanguageType(0x081D),      // alternative primary level
                      LANGUAGE_UKRAINIANLanguageType(0x0422),            // primary level
                      LANGUAGE_USER_ARAGONESELanguageType(0x0665),       // primary level
                      LANGUAGE_USER_ASTURIANLanguageType(0x064A) ) ||    // primary level
                  primary(eLang) == primary(LANGUAGE_GERMANLanguageType(0x0407)) ||  // alternative primary level
                  primary(eLang) == primary(LANGUAGE_SPANISHLanguageType(0x0C0A)) )  // primary level
              {
                  InsertQuote( rDoc, nInsPos, cChar, false, bInsert, eLang, ACQuotes::DoubleAngleQuote );
                  break;
              }
          }

          if( bInsert )
              rDoc.Insert( nInsPos, OUString(cChar) );
          else
              rDoc.Replace( nInsPos, OUString(cChar) );

          // Hardspaces autocorrection
          if ( IsAutoCorrFlag( ACFlags::AddNonBrkSpace ) )
          {
              if ( NeedsHardspaceAutocorr( cChar ) &&
                  FnAddNonBrkSpace( rDoc, rTxt, nInsPos, GetDocLanguage( rDoc, nInsPos ), io_bNbspRunNext ) )
              {
                  ;
              }
              else if ( bIsNextRun && !IsAutoCorrectChar( cChar ) )
              {
                  // Remove the NBSP if it wasn't an autocorrection
                  if ( nInsPos != 0 && NeedsHardspaceAutocorr( rTxt[ nInsPos - 1 ] ) &&
                          cChar != ' ' && cChar != '\t' && cChar != cNonBreakingSpace )
                  {
                      // Look for the last HARD_SPACE
                      sal_Int32 nPos = nInsPos - 1;
                      bool bContinue = true;
                      while ( bContinue )
                      {
                          const sal_Unicode cTmpChar = rTxt[ nPos ];
                          if ( cTmpChar == cNonBreakingSpace )
                          {
                              rDoc.Delete( nPos, nPos + 1 );
                              bContinue = false;
                          }
                          else if ( !NeedsHardspaceAutocorr( cTmpChar ) || nPos == 0 )
                              bContinue = false;
                          nPos--;
                      }
                  }
              }
          }
      }

      if( !nInsPos )
          break;

      sal_Int32 nPos = nInsPos - 1;

      if( IsWordDelim( rTxt[ nPos ]))
          break;

      // Set bold or underline automatically?
      if (('*' == cChar || '_' == cChar || '/' == cChar || '-' == cChar) && (nPos+1 < rTxt.getLength()))
      {
          if( IsAutoCorrFlag( ACFlags::ChgWeightUnderl ) )
          {
              FnChgWeightUnderl( rDoc, rTxt, nPos+1 );
          }
          break;
      }

      while( nPos && !IsWordDelim( rTxt[ --nPos ]))
          ;

      // Found a Paragraph-start or a Blank, search for the word shortcut in
      // auto.
      sal_Int32 nCapLttrPos = nPos+1;        // on the 1st Character
      if( !nPos && !IsWordDelim( rTxt[ 0 ]))
          --nCapLttrPos;          // begin of paragraph and no blank

      const LanguageType eLang = GetDocLanguage( rDoc, nCapLttrPos );
      CharClass& rCC = GetCharClass( eLang );

      // no symbol characters
      if( lcl_IsSymbolChar( rCC, rTxt, nCapLttrPos, nInsPos ))
          break;

      if( IsAutoCorrFlag( ACFlags::Autocorrect ) )
      {
          // WARNING ATTENTION: rTxt is an alias of the text node's OUString
          // and becomes INVALID if ChgAutoCorrWord returns true!
          // => use aPara/pPara to create a valid copy of the string!
          OUString aPara;
          OUString* pPara = IsAutoCorrFlag(ACFlags::CapitalStartSentence) ? &aPara : nullptr;

          bool bChgWord = rDoc.ChgAutoCorrWord( nCapLttrPos, nInsPos,
                                                  *this, pPara );
          if( !bChgWord )
          {
              sal_Int32 nCapLttrPos1 = nCapLttrPos, nInsPos1 = nInsPos;
              while( nCapLttrPos1 < nInsPos &&
                      lcl_IsInAsciiArr( sImplSttSkipChars, rTxt[ nCapLttrPos1 ] )
                      )
                      ++nCapLttrPos1;
              while( nCapLttrPos1 < nInsPos1 && nInsPos1 &&
                      lcl_IsInAsciiArr( sImplEndSkipChars, rTxt[ nInsPos1-1 ] )
                      )
                      --nInsPos1;

              if( (nCapLttrPos1 != nCapLttrPos || nInsPos1 != nInsPos ) &&
                  nCapLttrPos1 < nInsPos1 &&
                  rDoc.ChgAutoCorrWord( nCapLttrPos1, nInsPos1, *this, pPara ))
              {
                  bChgWord = true;
                  nCapLttrPos = nCapLttrPos1;
              }
          }

          if( bChgWord )
          {
              if( !aPara.isEmpty() )
              {
                  sal_Int32 nEnd = nCapLttrPos;
                  while( nEnd < aPara.getLength() &&
                          !IsWordDelim( aPara[ nEnd ]))
                      ++nEnd;

                  // Capital letter at beginning of paragraph?
                  if( IsAutoCorrFlag( ACFlags::CapitalStartSentence ) )
                  {
                      FnCapitalStartSentence( rDoc, aPara, false,
                                              nCapLttrPos, nEnd, eLang );
                  }

                  if( IsAutoCorrFlag( ACFlags::ChgToEnEmDash ) )
                  {
                      FnChgToEnEmDash( rDoc, aPara, nCapLttrPos, nEnd, eLang );
                  }
              }
              break;
          }
      }

      if( IsAutoCorrFlag( ACFlags::TransliterateRTL ) && GetDocLanguage( rDoc, nInsPos ) == LANGUAGE_HUNGARIANLanguageType(0x040E) )
      {
          // WARNING ATTENTION: rTxt is an alias of the text node's OUString
          // and becomes INVALID if TransliterateRTLWord returns true!
          if ( rDoc.TransliterateRTLWord( nCapLttrPos, nInsPos ) )
              break;
      }

      if( ( IsAutoCorrFlag( ACFlags::ChgOrdinalNumber ) &&
              (nInsPos >= 2 ) &&       // fdo#69762 avoid autocorrect for 2e-3
              ( '-' != cChar || 'E' != rtl::toAsciiUpperCase(rTxt[nInsPos-1]) || '0' > rTxt[nInsPos-2] || '9' < rTxt[nInsPos-2] ) &&
              FnChgOrdinalNumber( rDoc, rTxt, nCapLttrPos, nInsPos, eLang ) ) ||
          ( IsAutoCorrFlag( ACFlags::SetINetAttr ) &&
              ( ' ' == cChar || '\t' == cChar || 0x0a == cChar || !cChar ) &&
              FnSetINetAttr( rDoc, rTxt, nCapLttrPos, nInsPos, eLang ) ) )
          ;
      else
      {
          bool bLockKeyOn = pFrameWin && (pFrameWin->GetIndicatorState() & KeyIndicatorState::CAPSLOCK);
          bool bUnsupported = lcl_IsUnsupportedUnicodeChar( rCC, rTxt, nCapLttrPos, nInsPos );

          if ( bLockKeyOn && IsAutoCorrFlag( ACFlags::CorrectCapsLock ) &&
               FnCorrectCapsLock( rDoc, rTxt, nCapLttrPos, nInsPos, eLang ) )
          {
              // Correct accidental use of cAPS LOCK key (do this only when
              // the caps or shift lock key is pressed). Turn off the caps
              // lock afterwards.
              pFrameWin->SimulateKeyPress( KEY_CAPSLOCK );
          }

          // Capital letter at beginning of paragraph ?
          if( !bUnsupported &&
              IsAutoCorrFlag( ACFlags::CapitalStartSentence ) )
          {
              FnCapitalStartSentence( rDoc, rTxt, true, nCapLttrPos, nInsPos, eLang );
          }

          // Two capital letters at beginning of word ??
          if( !bUnsupported &&
              IsAutoCorrFlag( ACFlags::CapitalStartWord ) )
          {
              FnCapitalStartWord( rDoc, rTxt, nCapLttrPos, nInsPos, eLang );
          }

          if( IsAutoCorrFlag( ACFlags::ChgToEnEmDash ) )
          {
              FnChgToEnEmDash( rDoc, rTxt, nCapLttrPos, nInsPos, eLang );
          }
      }

  } while( false );
1625}

1627SvxAutoCorrectLanguageLists& SvxAutoCorrect::GetLanguageList_(
                                                      LanguageType eLang )
1629{
  LanguageTag aLanguageTag( eLang);
  if (m_aLangTable.find(aLanguageTag) == m_aLangTable.end())
      (void)CreateLanguageFile(aLanguageTag);
  return *(m_aLangTable.find(aLanguageTag)->second);
1634}

1636void SvxAutoCorrect::SaveCplSttExceptList( LanguageType eLang )
1637{
  auto const iter = m_aLangTable.find(LanguageTag(eLang));
  if (iter != m_aLangTable.end() && iter->second)
      iter->second->SaveCplSttExceptList();
  else
  {
      SAL_WARN("editeng", "Save an empty list? ")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "editeng")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Save an empty list? "
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"
), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1643" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Save an empty list? "), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "Save an empty list? "; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1643" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Save an empty list? ") == 1) { ::sal_detail_log(
 (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1643" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Save an empty list? "), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "Save an empty list? "; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1643" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
1645}

1647void SvxAutoCorrect::SaveWrdSttExceptList(LanguageType eLang)
1648{
  auto const iter = m_aLangTable.find(LanguageTag(eLang));
  if (iter != m_aLangTable.end() && iter->second)
      iter->second->SaveWrdSttExceptList();
  else
  {
      SAL_WARN("editeng", "Save an empty list? ")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "editeng")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "Save an empty list? "
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"
), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1654" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Save an empty list? "), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "Save an empty list? "; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1654" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "Save an empty list? ") == 1) { ::sal_detail_log(
 (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1654" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "Save an empty list? "), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "Save an empty list? "; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1654" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  }
1656}

1658// Adds a single word. The list will immediately be written to the file!
1659bool SvxAutoCorrect::AddCplSttException( const OUString& rNew,
                                      LanguageType eLang )
1661{
  SvxAutoCorrectLanguageLists* pLists = nullptr;
  // either the right language is present or it will be this in the general list
  auto iter = m_aLangTable.find(LanguageTag(eLang));
  if (iter != m_aLangTable.end())
      pLists = iter->second.get();
  else
  {
      LanguageTag aLangTagUndetermined( LANGUAGE_UNDETERMINEDLanguageType(0xFFF0));
      iter = m_aLangTable.find(aLangTagUndetermined);
      if (iter != m_aLangTable.end())
          pLists = iter->second.get();
      else if(CreateLanguageFile(aLangTagUndetermined))
          pLists = m_aLangTable.find(aLangTagUndetermined)->second.get();
  }
  OSL_ENSURE(pLists, "No auto correction data")do { if (true && (!(pLists))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1676" ": "), "%s", "No auto correction data"); } } while
 (false);
  return pLists && pLists->AddToCplSttExceptList(rNew);
1678}

1680// Adds a single word. The list will immediately be written to the file!
1681bool SvxAutoCorrect::AddWrtSttException( const OUString& rNew,
                                       LanguageType eLang )
1683{
  SvxAutoCorrectLanguageLists* pLists = nullptr;
  //either the right language is present or it is set in the general list
  auto iter = m_aLangTable.find(LanguageTag(eLang));
  if (iter != m_aLangTable.end())
      pLists = iter->second.get();
  else
  {
      LanguageTag aLangTagUndetermined( LANGUAGE_UNDETERMINEDLanguageType(0xFFF0));
      iter = m_aLangTable.find(aLangTagUndetermined);
      if (iter != m_aLangTable.end())
          pLists = iter->second.get();
      else if(CreateLanguageFile(aLangTagUndetermined))
          pLists = m_aLangTable.find(aLangTagUndetermined)->second.get();
  }
  OSL_ENSURE(pLists, "No auto correction file!")do { if (true && (!(pLists))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1698" ": "), "%s", "No auto correction file!"); } } while
 (false);
  return pLists && pLists->AddToWrdSttExceptList(rNew);
1700}

1702OUString SvxAutoCorrect::GetPrevAutoCorrWord(SvxAutoCorrDoc const& rDoc, const OUString& rTxt,
                                           sal_Int32 nPos)
1704{
  OUString sRet;
  if( !nPos )
      return sRet;

  sal_Int32 nEnd = nPos;

  // it must be followed by a blank or tab!
  if( ( nPos < rTxt.getLength() &&
      !IsWordDelim( rTxt[ nPos ])) ||
      IsWordDelim( rTxt[ --nPos ]))
      return sRet;

  while( nPos && !IsWordDelim( rTxt[ --nPos ]))
      ;

  // Found a Paragraph-start or a Blank, search for the word shortcut in
  // auto.
  sal_Int32 nCapLttrPos = nPos+1;        // on the 1st Character
  if( !nPos && !IsWordDelim( rTxt[ 0 ]))
      --nCapLttrPos;          // Beginning of paragraph and no Blank!

  while( lcl_IsInAsciiArr( sImplSttSkipChars, rTxt[ nCapLttrPos ]) )
      if( ++nCapLttrPos >= nEnd )
          return sRet;

  if( 3 > nEnd - nCapLttrPos )
      return sRet;

  const LanguageType eLang = GetDocLanguage( rDoc, nCapLttrPos );

  CharClass& rCC = GetCharClass(eLang);

  if( lcl_IsSymbolChar( rCC, rTxt, nCapLttrPos, nEnd ))
      return sRet;

  sRet = rTxt.copy( nCapLttrPos, nEnd - nCapLttrPos );
  return sRet;
1742}

1744// static
1745std::vector<OUString> SvxAutoCorrect::GetChunkForAutoText(const OUString& rTxt,
                                                        const sal_Int32 nPos)
1747{
  constexpr sal_Int32 nMinLen = 3;
  constexpr sal_Int32 nMaxLen = 9;
  std::vector<OUString> aRes;
  if (nPos >= nMinLen)
  {
      sal_Int32 nBegin = std::max<sal_Int32>(nPos - nMaxLen, 0);
      // TODO: better detect word boundaries (not only whitespaces, but also e.g. punctuation)
      if (nBegin > 0 && !IsWordDelim(rTxt[nBegin-1]))
      {
          while (nBegin + nMinLen <= nPos && !IsWordDelim(rTxt[nBegin]))
              ++nBegin;
      }
      if (nBegin + nMinLen <= nPos)
      {
          OUString sRes = rTxt.copy(nBegin, nPos - nBegin);
          aRes.push_back(sRes);
          bool bLastStartedWithDelim = IsWordDelim(sRes[0]);
          for (sal_Int32 i = 1; i <= sRes.getLength() - nMinLen; ++i)
          {
              bool bAdd = bLastStartedWithDelim;
              bLastStartedWithDelim = IsWordDelim(sRes[i]);
              bAdd = bAdd || bLastStartedWithDelim;
              if (bAdd)
                  aRes.push_back(sRes.copy(i));
          }
      }
  }
  return aRes;
1776}

1778bool SvxAutoCorrect::CreateLanguageFile( const LanguageTag& rLanguageTag, bool bNewFile )
1779{
  OSL_ENSURE(m_aLangTable.find(rLanguageTag) == m_aLangTable.end(), "Language already exists ")do { if (true && (!(m_aLangTable.find(rLanguageTag) ==
 m_aLangTable.end()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "1780" ": "), "%s", "Language already exists "); } } while
 (false);

  OUString sUserDirFile( GetAutoCorrFileName( rLanguageTag, true ));
  OUString sShareDirFile( sUserDirFile );

  SvxAutoCorrectLanguageLists* pLists = nullptr;

  tools::Time nMinTime( 0, 2 ), nAktTime( tools::Time::SYSTEM ), nLastCheckTime( tools::Time::EMPTY );

  auto nFndPos = aLastFileTable.find(rLanguageTag);
  if(nFndPos != aLastFileTable.end() &&
     (nLastCheckTime.SetTime(nFndPos->second), nLastCheckTime < nAktTime) &&
     nAktTime - nLastCheckTime < nMinTime)
  {
      // no need to test the file, because the last check is not older then
      // 2 minutes.
      if( bNewFile )
      {
          sShareDirFile = sUserDirFile;
          pLists = new SvxAutoCorrectLanguageLists( *this, sShareDirFile, sUserDirFile );
          LanguageTag aTmp(rLanguageTag);     // this insert() needs a non-const reference
          m_aLangTable.insert(std::make_pair(aTmp, std::unique_ptr<SvxAutoCorrectLanguageLists>(pLists)));
          aLastFileTable.erase(nFndPos);
      }
  }
  else if(
           ( FStatHelper::IsDocument( sUserDirFile ) ||
             FStatHelper::IsDocument( sShareDirFile =
                 GetAutoCorrFileName( rLanguageTag ) ) ||
             FStatHelper::IsDocument( sShareDirFile =
                 GetAutoCorrFileName( rLanguageTag, false, false, true) )
           ) ||
      ( sShareDirFile = sUserDirFile, bNewFile )
        )
  {
      pLists = new SvxAutoCorrectLanguageLists( *this, sShareDirFile, sUserDirFile );
      LanguageTag aTmp(rLanguageTag);     // this insert() needs a non-const reference
      m_aLangTable.insert(std::make_pair(aTmp, std::unique_ptr<SvxAutoCorrectLanguageLists>(pLists)));
      if (nFndPos != aLastFileTable.end())
          aLastFileTable.erase(nFndPos);
  }
  else if( !bNewFile )
  {
      aLastFileTable[rLanguageTag] = nAktTime.GetTime();
  }
  return pLists != nullptr;
1826}

1828bool SvxAutoCorrect::PutText( const OUString& rShort, const OUString& rLong,
                              LanguageType eLang )
1830{
  LanguageTag aLanguageTag( eLang);
  auto const iter = m_aLangTable.find(aLanguageTag);
  if (iter != m_aLangTable.end())
      return iter->second->PutText(rShort, rLong);
  if(CreateLanguageFile(aLanguageTag))
      return m_aLangTable.find(aLanguageTag)->second->PutText(rShort, rLong);
  return false;
1838}

1840void SvxAutoCorrect::MakeCombinedChanges( std::vector<SvxAutocorrWord>& aNewEntries,
                                            std::vector<SvxAutocorrWord>& aDeleteEntries,
                                            LanguageType eLang )
1843{
  LanguageTag aLanguageTag( eLang);
  auto const iter = m_aLangTable.find(aLanguageTag);
  if (iter != m_aLangTable.end())
1
Taking true branch→
  {
      iter->second->MakeCombinedChanges( aNewEntries, aDeleteEntries );
2
←
Calling 'SvxAutoCorrectLanguageLists::MakeCombinedChanges'→
  }
  else if(CreateLanguageFile( aLanguageTag ))
  {
      m_aLangTable.find( aLanguageTag )->second->MakeCombinedChanges( aNewEntries, aDeleteEntries );
  }
1854}

1856//  - return the replacement text (only for SWG-Format, all other
1857//    can be taken from the word list!)
1858bool SvxAutoCorrect::GetLongText( const OUString&, OUString& )
1859{
  return false;
1861}

1863void SvxAutoCorrect::refreshBlockList( const uno::Reference< embed::XStorage >& )
1864{
1865}

1867// Text with attribution (only the SWG - SWG format!)
1868bool SvxAutoCorrect::PutText( const css::uno::Reference < css::embed::XStorage >&,
                            const OUString&, const OUString&, SfxObjectShell&, OUString& )
1870{
  return false;
1872}

1874OUString EncryptBlockName_Imp(const OUString& rName)
1875{
  OUStringBuffer aName;
  aName.append('#').append(rName);
  for (sal_Int32 nLen = rName.getLength(), nPos = 1; nPos < nLen; ++nPos)
  {
      if (lcl_IsInAsciiArr( "!/:.\\", aName[nPos]))
          aName[nPos] &= 0x0f;
  }
  return aName.makeStringAndClear();
1884}

1886/* This code is copied from SwXMLTextBlocks::GeneratePackageName */
1887static void GeneratePackageName ( const OUString& rShort, OUString& rPackageName )
1888{
  OString sByte(OUStringToOString(rShort, RTL_TEXTENCODING_UTF7(((rtl_TextEncoding) 75))));
  OUStringBuffer aBuf(OStringToOUString(sByte, RTL_TEXTENCODING_ASCII_US(((rtl_TextEncoding) 11))));

  for (sal_Int32 nPos = 0; nPos < aBuf.getLength(); ++nPos)
  {
      switch (aBuf[nPos])
      {
          case '!':
          case '/':
          case ':':
          case '.':
          case '\\':
              aBuf[nPos] = '_';
              break;
          default:
              break;
      }
  }

  rPackageName = aBuf.makeStringAndClear();
1909}

1911static const SvxAutocorrWord* lcl_SearchWordsInList(
              SvxAutoCorrectLanguageLists* pList, const OUString& rTxt,
              sal_Int32& rStt, sal_Int32 nEndPos)
1914{
  const SvxAutocorrWordList* pAutoCorrWordList = pList->GetAutocorrWordList();
  return pAutoCorrWordList->SearchWordsInList( rTxt, rStt, nEndPos );
1917}

1919// the search for the words in the substitution table
1920const SvxAutocorrWord* SvxAutoCorrect::SearchWordsInList(
              const OUString& rTxt, sal_Int32& rStt, sal_Int32 nEndPos,
              SvxAutoCorrDoc&, LanguageTag& rLang )
1923{
  const SvxAutocorrWord* pRet = nullptr;
  LanguageTag aLanguageTag( rLang);
  if( aLanguageTag.isSystemLocale() )
      aLanguageTag.reset( MsLangId::getSystemLanguage());

  /* TODO-BCP47: this is so ugly, should all maybe be a proper fallback
   * list instead? */

  // First search for eLang, then US-English -> English
  // and last in LANGUAGE_UNDETERMINED
  if (m_aLangTable.find(aLanguageTag) != m_aLangTable.end() || CreateLanguageFile(aLanguageTag, false))
  {
      //the language is available - so bring it on
      std::unique_ptr<SvxAutoCorrectLanguageLists> const& pList = m_aLangTable.find(aLanguageTag)->second;
      pRet = lcl_SearchWordsInList( pList.get(), rTxt, rStt, nEndPos );
      if( pRet )
      {
          rLang = aLanguageTag;
          return pRet;
      }
  }

  // If it still could not be found here, then keep on searching
  LanguageType eLang = aLanguageTag.getLanguageType();
  // the primary language for example EN
  aLanguageTag.reset(aLanguageTag.getLanguage());
  LanguageType nTmpKey = aLanguageTag.getLanguageType(false);
  if (nTmpKey != eLang && nTmpKey != LANGUAGE_UNDETERMINEDLanguageType(0xFFF0) &&
              (m_aLangTable.find(aLanguageTag) != m_aLangTable.end() ||
               CreateLanguageFile(aLanguageTag, false)))
  {
      //the language is available - so bring it on
      std::unique_ptr<SvxAutoCorrectLanguageLists> const& pList = m_aLangTable.find(aLanguageTag)->second;
      pRet = lcl_SearchWordsInList( pList.get(), rTxt, rStt, nEndPos );
      if( pRet )
      {
          rLang = aLanguageTag;
          return pRet;
      }
  }

  if (m_aLangTable.find(aLanguageTag.reset(LANGUAGE_UNDETERMINEDLanguageType(0xFFF0))) != m_aLangTable.end() ||
          CreateLanguageFile(aLanguageTag, false))
  {
      //the language is available - so bring it on
      std::unique_ptr<SvxAutoCorrectLanguageLists> const& pList = m_aLangTable.find(aLanguageTag)->second;
      pRet = lcl_SearchWordsInList( pList.get(), rTxt, rStt, nEndPos );
      if( pRet )
      {
          rLang = aLanguageTag;
          return pRet;
      }
  }
  return nullptr;
1978}

1980bool SvxAutoCorrect::FindInWrdSttExceptList( LanguageType eLang,
                                           const OUString& sWord )
1982{
  LanguageTag aLanguageTag( eLang);

  /* TODO-BCP47: again horrible ugliness */

  // First search for eLang, then primary language of eLang
  // and last in LANGUAGE_UNDETERMINED

  if (m_aLangTable.find(aLanguageTag) != m_aLangTable.end() || CreateLanguageFile(aLanguageTag, false))
  {
      //the language is available - so bring it on
      auto const& pList = m_aLangTable.find(aLanguageTag)->second;
      if(pList->GetWrdSttExceptList()->find(sWord) != pList->GetWrdSttExceptList()->end() )
          return true;
  }

  // If it still could not be found here, then keep on searching
  // the primary language for example EN
  aLanguageTag.reset(aLanguageTag.getLanguage());
  LanguageType nTmpKey = aLanguageTag.getLanguageType(false);
  if (nTmpKey != eLang && nTmpKey != LANGUAGE_UNDETERMINEDLanguageType(0xFFF0) &&
              (m_aLangTable.find(aLanguageTag) != m_aLangTable.end() ||
               CreateLanguageFile(aLanguageTag, false)))
  {
      //the language is available - so bring it on
      auto const& pList = m_aLangTable.find(aLanguageTag)->second;
      if(pList->GetWrdSttExceptList()->find(sWord) != pList->GetWrdSttExceptList()->end() )
          return true;
  }

  if (m_aLangTable.find(aLanguageTag.reset(LANGUAGE_UNDETERMINEDLanguageType(0xFFF0))) != m_aLangTable.end() ||
          CreateLanguageFile(aLanguageTag, false))
  {
      //the language is available - so bring it on
      auto const& pList = m_aLangTable.find(aLanguageTag)->second;
      if(pList->GetWrdSttExceptList()->find(sWord) != pList->GetWrdSttExceptList()->end() )
          return true;
  }
  return false;
2021}

2023static bool lcl_FindAbbreviation(const SvStringsISortDtor* pList, const OUString& sWord)
2024{
  SvStringsISortDtor::const_iterator it = pList->find( "~" );
  SvStringsISortDtor::size_type nPos = it - pList->begin();
  if( nPos < pList->size() )
  {
      OUString sLowerWord(sWord.toAsciiLowerCase());
      OUString sAbr;
      for( SvStringsISortDtor::size_type n = nPos; n < pList->size(); ++n )
      {
          sAbr = (*pList)[ n ];
          if (sAbr[0] != '~')
              break;
          // ~ and ~. are not allowed!
          if( 2 < sAbr.getLength() && sAbr.getLength() - 1 <= sWord.getLength() )
          {
              OUString sLowerAbk(sAbr.toAsciiLowerCase());
              for (sal_Int32 i = sLowerAbk.getLength(), ii = sLowerWord.getLength(); i;)
              {
                  if( !--i )      // agrees
                      return true;

                  if( sLowerAbk[i] != sLowerWord[--ii])
                      break;
              }
          }
      }
  }
  OSL_ENSURE( !(nPos && '~' == (*pList)[ --nPos ][ 0 ] ),do { if (true && (!(!(nPos && '~' == (*pList)
[ --nPos ][ 0 ] )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2052" ": "), "%s", "Wrongly sorted exception list?"); }
 } while (false)
          "Wrongly sorted exception list?" )do { if (true && (!(!(nPos && '~' == (*pList)
[ --nPos ][ 0 ] )))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2052" ": "), "%s", "Wrongly sorted exception list?"); }
 } while (false);
  return false;
2054}

2056bool SvxAutoCorrect::FindInCplSttExceptList(LanguageType eLang,
                              const OUString& sWord, bool bAbbreviation)
2058{
  LanguageTag aLanguageTag( eLang);

  /* TODO-BCP47: did I mention terrible horrible ugliness? */

  // First search for eLang, then primary language of eLang
  // and last in LANGUAGE_UNDETERMINED

  if (m_aLangTable.find(aLanguageTag) != m_aLangTable.end() || CreateLanguageFile(aLanguageTag, false))
  {
      //the language is available - so bring it on
      const SvStringsISortDtor* pList = m_aLangTable.find(aLanguageTag)->second->GetCplSttExceptList();
      if(bAbbreviation ? lcl_FindAbbreviation(pList, sWord) : pList->find(sWord) != pList->end() )
          return true;
  }

  // If it still could not be found here, then keep on searching
  // the primary language for example EN
  aLanguageTag.reset(aLanguageTag.getLanguage());
  LanguageType nTmpKey = aLanguageTag.getLanguageType(false);
  if (nTmpKey != eLang && nTmpKey != LANGUAGE_UNDETERMINEDLanguageType(0xFFF0) &&
              (m_aLangTable.find(aLanguageTag) != m_aLangTable.end() ||
               CreateLanguageFile(aLanguageTag, false)))
  {
      //the language is available - so bring it on
      const SvStringsISortDtor* pList = m_aLangTable.find(aLanguageTag)->second->GetCplSttExceptList();
      if(bAbbreviation ? lcl_FindAbbreviation(pList, sWord) : pList->find(sWord) != pList->end() )
          return true;
  }

  if (m_aLangTable.find(aLanguageTag.reset(LANGUAGE_UNDETERMINEDLanguageType(0xFFF0))) != m_aLangTable.end() ||
          CreateLanguageFile(aLanguageTag, false))
  {
      //the language is available - so bring it on
      const SvStringsISortDtor* pList = m_aLangTable.find(aLanguageTag)->second->GetCplSttExceptList();
      if(bAbbreviation ? lcl_FindAbbreviation(pList, sWord) : pList->find(sWord) != pList->end() )
          return true;
  }
  return false;
2097}

2099OUString SvxAutoCorrect::GetAutoCorrFileName( const LanguageTag& rLanguageTag,
                                          bool bNewFile, bool bTst, bool bUnlocalized ) const
2101{
  OUString sRet, sExt( rLanguageTag.getBcp47() );
  if (bUnlocalized)
  {
      // we don't want variant, so we'll take "fr" instead of "fr-CA" for example
      std::vector< OUString > vecFallBackStrings = rLanguageTag.getFallbackStrings(false);
      if (!vecFallBackStrings.empty())
         sExt = vecFallBackStrings[0];
  }

  sExt = "_" + sExt + ".dat";
  if( bNewFile )
      sRet = sUserAutoCorrFile + sExt;
  else if( !bTst )
      sRet = sShareAutoCorrFile + sExt;
  else
  {
      // test first in the user directory - if not exist, then
      sRet = sUserAutoCorrFile + sExt;
      if( !FStatHelper::IsDocument( sRet ))
          sRet = sShareAutoCorrFile + sExt;
  }
  return sRet;
2124}

2126SvxAutoCorrectLanguageLists::SvxAutoCorrectLanguageLists(
              SvxAutoCorrect& rParent,
              const OUString& rShareAutoCorrectFile,
              const OUString& rUserAutoCorrectFile)
  sShareAutoCorrFile( rShareAutoCorrectFile ),
  sUserAutoCorrFile( rUserAutoCorrectFile ),
  aModifiedDate( Date::EMPTY ),
  aModifiedTime( tools::Time::EMPTY ),
  aLastCheckTime( tools::Time::EMPTY ),
  rAutoCorrect(rParent),
  nFlags(ACFlags::NONE)
2137{
2138}

2140SvxAutoCorrectLanguageLists::~SvxAutoCorrectLanguageLists()
2141{
2142}

2144bool SvxAutoCorrectLanguageLists::IsFileChanged_Imp()
2145{
  // Access the file system only every 2 minutes to check the date stamp
  bool bRet = false;

  tools::Time nMinTime( 0, 2 );
  tools::Time nAktTime( tools::Time::SYSTEM );
  if( aLastCheckTime <= nAktTime) // overflow?
      return false;
  nAktTime -= aLastCheckTime;
  if( nAktTime > nMinTime )     // min time past
  {
      Date aTstDate( Date::EMPTY ); tools::Time aTstTime( tools::Time::EMPTY );
      if( FStatHelper::GetModifiedDateTimeOfFile( sShareAutoCorrFile,
                                          &aTstDate, &aTstTime ) &&
          ( aModifiedDate != aTstDate || aModifiedTime != aTstTime ))
      {
          bRet = true;
          // then remove all the lists fast!
          if( (ACFlags::CplSttLstLoad & nFlags) && pCplStt_ExcptLst )
          {
              pCplStt_ExcptLst.reset();
          }
          if( (ACFlags::WrdSttLstLoad & nFlags) && pWrdStt_ExcptLst )
          {
              pWrdStt_ExcptLst.reset();
          }
          if( (ACFlags::ChgWordLstLoad & nFlags) && pAutocorr_List )
          {
              pAutocorr_List.reset();
          }
          nFlags &= ~ACFlags(ACFlags::CplSttLstLoad | ACFlags::WrdSttLstLoad | ACFlags::ChgWordLstLoad );
      }
      aLastCheckTime = tools::Time( tools::Time::SYSTEM );
  }
  return bRet;
2180}

2182void SvxAutoCorrectLanguageLists::LoadXMLExceptList_Imp(
                                      std::unique_ptr<SvStringsISortDtor>& rpLst,
                                      const char* pStrmName,
                                      tools::SvRef<SotStorage>& rStg)
2186{
  if( rpLst )
      rpLst->clear();
  else
      rpLst.reset( new SvStringsISortDtor );

  {
      const OUString sStrmName( pStrmName, strlen(pStrmName), RTL_TEXTENCODING_MS_1252(((rtl_TextEncoding) 1)) );

      if( rStg.is() && rStg->IsStream( sStrmName ) )
      {
          tools::SvRef<SotStorageStream> xStrm = rStg->OpenSotStream( sStrmName,
              ( StreamMode::READ | StreamMode::SHARE_DENYWRITE | StreamMode::NOCREATE ) );
          if( ERRCODE_NONEErrCode(0) != xStrm->GetError())
          {
              xStrm.clear();
              rStg.clear();
              RemoveStream_Imp( sStrmName );
          }
          else
          {
              uno::Reference< uno::XComponentContext > xContext =
                  comphelper::getProcessComponentContext();

              xml::sax::InputSource aParserInput;
              aParserInput.sSystemId = sStrmName;

              xStrm->Seek( 0 );
              xStrm->SetBufferSize( 8 * 1024 );
              aParserInput.aInputStream = new utl::OInputStreamWrapper( *xStrm );

              // get filter
              rtl::Reference< SvXMLExceptionListImport > xImport = new SvXMLExceptionListImport ( xContext, *rpLst );

              // connect parser and filter
              uno::Reference<xml::sax::XFastTokenHandler> xTokenHandler = new SvXMLAutoCorrectTokenHandler;
              xImport->setTokenHandler( xTokenHandler );

              // parse
              try
              {
                  xImport->parseStream( aParserInput );
              }
              catch( const xml::sax::SAXParseException& )
              {
                  // re throw ?
              }
              catch( const xml::sax::SAXException& )
              {
                  // re throw ?
              }
              catch( const io::IOException& )
              {
                  // re throw ?
              }
          }
      }

      // Set time stamp
      FStatHelper::GetModifiedDateTimeOfFile( sShareAutoCorrFile,
                                      &aModifiedDate, &aModifiedTime );
      aLastCheckTime = tools::Time( tools::Time::SYSTEM );
  }

2250}

2252void SvxAutoCorrectLanguageLists::SaveExceptList_Imp(
                          const SvStringsISortDtor& rLst,
                          const char* pStrmName,
                          tools::SvRef<SotStorage> const &rStg,
                          bool bConvert )
2257{
  if( !rStg.is() )
      return;

  OUString sStrmName( pStrmName, strlen(pStrmName), RTL_TEXTENCODING_MS_1252(((rtl_TextEncoding) 1)) );
  if( rLst.empty() )
  {
      rStg->Remove( sStrmName );
      rStg->Commit();
  }
  else
  {
      tools::SvRef<SotStorageStream> xStrm = rStg->OpenSotStream( sStrmName,
              ( StreamMode::READ | StreamMode::WRITE | StreamMode::SHARE_DENYWRITE ) );
      if( xStrm.is() )
      {
          xStrm->SetSize( 0 );
          xStrm->SetBufferSize( 8192 );
          xStrm->SetProperty( "MediaType", Any(OUString( "text/xml" )) );


          uno::Reference< uno::XComponentContext > xContext =
              comphelper::getProcessComponentContext();

          uno::Reference < xml::sax::XWriter > xWriter  = xml::sax::Writer::create(xContext);
          uno::Reference < io::XOutputStream> xOut = new utl::OOutputStreamWrapper( *xStrm );
          xWriter->setOutputStream(xOut);

          uno::Reference < xml::sax::XDocumentHandler > xHandler(xWriter, UNO_QUERY_THROW);
          rtl::Reference< SvXMLExceptionListExport > xExp( new SvXMLExceptionListExport( xContext, rLst, sStrmName, xHandler ) );

          xExp->exportDoc( XML_BLOCK_LIST );

          xStrm->Commit();
          if( xStrm->GetError() == ERRCODE_NONEErrCode(0) )
          {
              xStrm.clear();
              if (!bConvert)
              {
                  rStg->Commit();
                  if( ERRCODE_NONEErrCode(0) != rStg->GetError() )
                  {
                      rStg->Remove( sStrmName );
                      rStg->Commit();
                  }
              }
          }
      }
  }
2306}

2308SvxAutocorrWordList* SvxAutoCorrectLanguageLists::LoadAutocorrWordList()
2309{
  if( pAutocorr_List )
      pAutocorr_List->DeleteAndDestroyAll();
  else
      pAutocorr_List.reset( new SvxAutocorrWordList() );

  try
  {
      uno::Reference < embed::XStorage > xStg = comphelper::OStorageHelper::GetStorageFromURL( sShareAutoCorrFile, embed::ElementModes::READ );
      uno::Reference < io::XStream > xStrm = xStg->openStreamElement( pXMLImplAutocorr_ListStr, embed::ElementModes::READ );
      uno::Reference< uno::XComponentContext > xContext = comphelper::getProcessComponentContext();

      xml::sax::InputSource aParserInput;
      aParserInput.sSystemId = pXMLImplAutocorr_ListStr;
      aParserInput.aInputStream = xStrm->getInputStream();

      // get parser
      uno::Reference< xml::sax::XFastParser > xParser = xml::sax::FastParser::create(xContext);
      SAL_INFO("editeng", "AutoCorrect Import" )do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "editeng")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "AutoCorrect Import")
 == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("editeng"
), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2327" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "AutoCorrect Import"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "AutoCorrect Import"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2327" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "AutoCorrect Import") == 1) { ::sal_detail_log( (
::SAL_DETAIL_LOG_LEVEL_INFO), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2327" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "AutoCorrect Import"), 0); } else { ::
std::ostringstream sal_detail_stream; sal_detail_stream <<
 "AutoCorrect Import"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2327" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
      uno::Reference< xml::sax::XFastDocumentHandler > xFilter = new SvXMLAutoCorrectImport( xContext, pAutocorr_List.get(), rAutoCorrect, xStg );
      uno::Reference<xml::sax::XFastTokenHandler> xTokenHandler = new SvXMLAutoCorrectTokenHandler;

      // connect parser and filter
      xParser->setFastDocumentHandler( xFilter );
      xParser->registerNamespace( "http://openoffice.org/2001/block-list", SvXMLAutoCorrectToken::NAMESPACE );
      xParser->setTokenHandler(xTokenHandler);

      // parse
      xParser->parseStream( aParserInput );
  }
  catch ( const uno::Exception& )
  {
      TOOLS_WARN_EXCEPTION("editeng", "when loading " << sShareAutoCorrFile)do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "editeng")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "when loading " <<
 sShareAutoCorrFile << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2341" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "when loading " << sShareAutoCorrFile
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "when loading " << sShareAutoCorrFile <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2341" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "when loading " << sShareAutoCorrFile <<
 " " << exceptionToString(tools_warn_exception)) == 1) {
 ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng")
, ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2341" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "when loading " << sShareAutoCorrFile
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "when loading " << sShareAutoCorrFile <<
 " " << exceptionToString(tools_warn_exception); ::sal::
detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2341" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }

  // Set time stamp
  FStatHelper::GetModifiedDateTimeOfFile( sShareAutoCorrFile,
                                  &aModifiedDate, &aModifiedTime );
  aLastCheckTime = tools::Time( tools::Time::SYSTEM );

  return pAutocorr_List.get();
2350}

2352const SvxAutocorrWordList* SvxAutoCorrectLanguageLists::GetAutocorrWordList()
2353{
  if( !( ACFlags::ChgWordLstLoad & nFlags ) || IsFileChanged_Imp() )
  {
      LoadAutocorrWordList();
      if( !pAutocorr_List )
      {
          OSL_ENSURE( false, "No valid list" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2359" ": "), "%s", "No valid list"); } } while (false);
          pAutocorr_List.reset( new SvxAutocorrWordList() );
      }
      nFlags |= ACFlags::ChgWordLstLoad;
  }
  return pAutocorr_List.get();
2365}

2367SvStringsISortDtor* SvxAutoCorrectLanguageLists::GetCplSttExceptList()
2368{
  if( !( ACFlags::CplSttLstLoad & nFlags ) || IsFileChanged_Imp() )
  {
      LoadCplSttExceptList();
      if( !pCplStt_ExcptLst )
      {
          OSL_ENSURE( false, "No valid list" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2374" ": "), "%s", "No valid list"); } } while (false);
          pCplStt_ExcptLst.reset( new SvStringsISortDtor );
      }
      nFlags |= ACFlags::CplSttLstLoad;
  }
  return pCplStt_ExcptLst.get();
2380}

2382bool SvxAutoCorrectLanguageLists::AddToCplSttExceptList(const OUString& rNew)
2383{
  bool bRet = false;
  if( !rNew.isEmpty() && GetCplSttExceptList()->insert( rNew ).second )
  {
      MakeUserStorage_Impl();
      tools::SvRef<SotStorage> xStg = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );

      SaveExceptList_Imp( *pCplStt_ExcptLst, pXMLImplCplStt_ExcptLstStr, xStg );

      xStg = nullptr;
      // Set time stamp
      FStatHelper::GetModifiedDateTimeOfFile( sUserAutoCorrFile,
                                          &aModifiedDate, &aModifiedTime );
      aLastCheckTime = tools::Time( tools::Time::SYSTEM );
      bRet = true;
  }
  return bRet;
2400}

2402bool SvxAutoCorrectLanguageLists::AddToWrdSttExceptList(const OUString& rNew)
2403{
  bool bRet = false;
  SvStringsISortDtor* pExceptList = LoadWrdSttExceptList();
  if( !rNew.isEmpty() && pExceptList && pExceptList->insert( rNew ).second )
  {
      MakeUserStorage_Impl();
      tools::SvRef<SotStorage> xStg = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );

      SaveExceptList_Imp( *pWrdStt_ExcptLst, pXMLImplWrdStt_ExcptLstStr, xStg );

      xStg = nullptr;
      // Set time stamp
      FStatHelper::GetModifiedDateTimeOfFile( sUserAutoCorrFile,
                                          &aModifiedDate, &aModifiedTime );
      aLastCheckTime = tools::Time( tools::Time::SYSTEM );
      bRet = true;
  }
  return bRet;
2421}

2423SvStringsISortDtor* SvxAutoCorrectLanguageLists::LoadCplSttExceptList()
2424{
  try
  {
      tools::SvRef<SotStorage> xStg = new SotStorage( sShareAutoCorrFile, StreamMode::READ | StreamMode::SHARE_DENYNONE );
      if( xStg.is() && xStg->IsContained( pXMLImplCplStt_ExcptLstStr ) )
          LoadXMLExceptList_Imp( pCplStt_ExcptLst, pXMLImplCplStt_ExcptLstStr, xStg );
  }
  catch (const css::ucb::ContentCreationException&)
  {
  }
  return pCplStt_ExcptLst.get();
2435}

2437void SvxAutoCorrectLanguageLists::SaveCplSttExceptList()
2438{
  MakeUserStorage_Impl();
  tools::SvRef<SotStorage> xStg = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );

  SaveExceptList_Imp( *pCplStt_ExcptLst, pXMLImplCplStt_ExcptLstStr, xStg );

  xStg = nullptr;

  // Set time stamp
  FStatHelper::GetModifiedDateTimeOfFile( sUserAutoCorrFile,
                                          &aModifiedDate, &aModifiedTime );
  aLastCheckTime = tools::Time( tools::Time::SYSTEM );
2450}

2452SvStringsISortDtor* SvxAutoCorrectLanguageLists::LoadWrdSttExceptList()
2453{
  try
  {
      tools::SvRef<SotStorage> xStg = new SotStorage( sShareAutoCorrFile, StreamMode::READ | StreamMode::SHARE_DENYNONE );
      if( xStg.is() && xStg->IsContained( pXMLImplWrdStt_ExcptLstStr ) )
          LoadXMLExceptList_Imp( pWrdStt_ExcptLst, pXMLImplWrdStt_ExcptLstStr, xStg );
  }
  catch (const css::ucb::ContentCreationException &)
  {
      TOOLS_WARN_EXCEPTION("editeng", "SvxAutoCorrectLanguageLists::LoadWrdSttExceptList")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "editeng")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "SvxAutoCorrectLanguageLists::LoadWrdSttExceptList"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2462" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SvxAutoCorrectLanguageLists::LoadWrdSttExceptList"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SvxAutoCorrectLanguageLists::LoadWrdSttExceptList"
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"
), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2462" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "SvxAutoCorrectLanguageLists::LoadWrdSttExceptList"
 << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"editeng"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2462" ": "), ::sal::detail::unwrapStream( ::sal::detail
::StreamStart() << "SvxAutoCorrectLanguageLists::LoadWrdSttExceptList"
 << " " << exceptionToString(tools_warn_exception
)), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "SvxAutoCorrectLanguageLists::LoadWrdSttExceptList"
 << " " << exceptionToString(tools_warn_exception
); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("editeng"
), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2462" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
  }
  return pWrdStt_ExcptLst.get();
2465}

2467void SvxAutoCorrectLanguageLists::SaveWrdSttExceptList()
2468{
  MakeUserStorage_Impl();
  tools::SvRef<SotStorage> xStg = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );

  SaveExceptList_Imp( *pWrdStt_ExcptLst, pXMLImplWrdStt_ExcptLstStr, xStg );

  xStg = nullptr;
  // Set time stamp
  FStatHelper::GetModifiedDateTimeOfFile( sUserAutoCorrFile,
                                          &aModifiedDate, &aModifiedTime );
  aLastCheckTime = tools::Time( tools::Time::SYSTEM );
2479}

2481SvStringsISortDtor* SvxAutoCorrectLanguageLists::GetWrdSttExceptList()
2482{
  if( !( ACFlags::WrdSttLstLoad & nFlags ) || IsFileChanged_Imp() )
  {
      LoadWrdSttExceptList();
      if( !pWrdStt_ExcptLst )
      {
          OSL_ENSURE( false, "No valid list" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/editeng/source/misc/svxacorr.cxx"
 ":" "2488" ": "), "%s", "No valid list"); } } while (false);
          pWrdStt_ExcptLst.reset( new SvStringsISortDtor );
      }
      nFlags |= ACFlags::WrdSttLstLoad;
  }
  return pWrdStt_ExcptLst.get();
2494}

2496void SvxAutoCorrectLanguageLists::RemoveStream_Imp( const OUString& rName )
2497{
  if( sShareAutoCorrFile != sUserAutoCorrFile )
  {
      tools::SvRef<SotStorage> xStg = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );
      if( xStg.is() && ERRCODE_NONEErrCode(0) == xStg->GetError() &&
          xStg->IsStream( rName ) )
      {
          xStg->Remove( rName );
          xStg->Commit();

          xStg = nullptr;
      }
  }
2510}

2512void SvxAutoCorrectLanguageLists::MakeUserStorage_Impl()
2513{
  // The conversion needs to happen if the file is already in the user
  // directory and is in the old format. Additionally it needs to
  // happen when the file is being copied from share to user.

  bool bError = false, bConvert = false, bCopy = false;
  INetURLObject aDest;
  INetURLObject aSource;

  if (sUserAutoCorrFile != sShareAutoCorrFile )
  {
      aSource = INetURLObject ( sShareAutoCorrFile );
      aDest = INetURLObject ( sUserAutoCorrFile );
      if ( SotStorage::IsOLEStorage ( sShareAutoCorrFile ) )
      {
          aDest.SetExtension ( "bak" );
          bConvert = true;
      }
      bCopy = true;
  }
  else if ( SotStorage::IsOLEStorage ( sUserAutoCorrFile ) )
  {
      aSource = INetURLObject ( sUserAutoCorrFile );
      aDest = INetURLObject ( sUserAutoCorrFile );
      aDest.SetExtension ( "bak" );
      bCopy = bConvert = true;
  }
  if (bCopy)
  {
      try
      {
          OUString sMain(aDest.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ));
          sal_Int32 nSlashPos = sMain.lastIndexOf('/');
          sMain = sMain.copy(0, nSlashPos);
          ::ucbhelper::Content aNewContent( sMain, uno::Reference< XCommandEnvironment >(), comphelper::getProcessComponentContext() );
          TransferInfo aInfo;
          aInfo.NameClash = NameClash::OVERWRITE;
          aInfo.NewTitle = aDest.GetLastName();
          aInfo.SourceURL = aSource.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );
          aInfo.MoveData  = false;
          aNewContent.executeCommand( "transfer", Any(aInfo));
      }
      catch (...)
      {
          bError = true;
      }
  }
  if (bConvert && !bError)
  {
      tools::SvRef<SotStorage> xSrcStg = new SotStorage( aDest.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ), StreamMode::READ );
      tools::SvRef<SotStorage> xDstStg = new SotStorage( sUserAutoCorrFile, StreamMode::WRITE );

      if( xSrcStg.is() && xDstStg.is() )
      {
          std::unique_ptr<SvStringsISortDtor> pTmpWordList;

          if (xSrcStg->IsContained( pXMLImplWrdStt_ExcptLstStr ) )
              LoadXMLExceptList_Imp( pTmpWordList, pXMLImplWrdStt_ExcptLstStr, xSrcStg );

          if (pTmpWordList)
          {
              SaveExceptList_Imp( *pTmpWordList, pXMLImplWrdStt_ExcptLstStr, xDstStg, true );
              pTmpWordList.reset();
          }


          if (xSrcStg->IsContained( pXMLImplCplStt_ExcptLstStr ) )
              LoadXMLExceptList_Imp( pTmpWordList, pXMLImplCplStt_ExcptLstStr, xSrcStg );

          if (pTmpWordList)
          {
              SaveExceptList_Imp( *pTmpWordList, pXMLImplCplStt_ExcptLstStr, xDstStg, true );
              pTmpWordList->clear();
          }

          GetAutocorrWordList();
          MakeBlocklist_Imp( *xDstStg );
          sShareAutoCorrFile = sUserAutoCorrFile;
          xDstStg = nullptr;
          try
          {
              ::ucbhelper::Content aContent ( aDest.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ), uno::Reference < XCommandEnvironment >(), comphelper::getProcessComponentContext() );
              aContent.executeCommand ( "delete", makeAny ( true ) );
          }
          catch (...)
          {
          }
      }
  }
  else if( bCopy && !bError )
      sShareAutoCorrFile = sUserAutoCorrFile;
2604}

2606bool SvxAutoCorrectLanguageLists::MakeBlocklist_Imp( SotStorage& rStg )
2607{
  bool bRet = true, bRemove = !pAutocorr_List || pAutocorr_List->empty();
  if( !bRemove )
  {
      tools::SvRef<SotStorageStream> refList = rStg.OpenSotStream( pXMLImplAutocorr_ListStr,
                  ( StreamMode::READ | StreamMode::WRITE | StreamMode::SHARE_DENYWRITE ) );
      if( refList.is() )
      {
          refList->SetSize( 0 );
          refList->SetBufferSize( 8192 );
          refList->SetProperty( "MediaType", Any(OUString( "text/xml" )) );

          uno::Reference< uno::XComponentContext > xContext =
              comphelper::getProcessComponentContext();

          uno::Reference < xml::sax::XWriter > xWriter = xml::sax::Writer::create(xContext);
          uno::Reference < io::XOutputStream> xOut = new utl::OOutputStreamWrapper( *refList );
          xWriter->setOutputStream(xOut);

          rtl::Reference< SvXMLAutoCorrectExport > xExp( new SvXMLAutoCorrectExport( xContext, pAutocorr_List.get(), pXMLImplAutocorr_ListStr, xWriter ) );

          xExp->exportDoc( XML_BLOCK_LIST );

          refList->Commit();
          bRet = ERRCODE_NONEErrCode(0) == refList->GetError();
          if( bRet )
          {
              refList.clear();
              rStg.Commit();
              if( ERRCODE_NONEErrCode(0) != rStg.GetError() )
              {
                  bRemove = true;
                  bRet = false;
              }
          }
      }
      else
          bRet = false;
  }

  if( bRemove )
  {
      rStg.Remove( pXMLImplAutocorr_ListStr );
      rStg.Commit();
  }

  return bRet;
2654}

2656bool SvxAutoCorrectLanguageLists::MakeCombinedChanges( std::vector<SvxAutocorrWord>& aNewEntries, std::vector<SvxAutocorrWord>& aDeleteEntries )
2657{
  // First get the current list!
  GetAutocorrWordList();

  MakeUserStorage_Impl();
  tools::SvRef<SotStorage> xStorage = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );
3
←
Memory is allocated→

  bool bRet = xStorage.is() && ERRCODE_NONEErrCode(0) == xStorage->GetError();

  if( bRet3.1
'bRet' is false
 )
4
←
Taking false branch→
  {
      for (SvxAutocorrWord & aWordToDelete : aDeleteEntries)
      {
          std::optional<SvxAutocorrWord> xFoundEntry = pAutocorr_List->FindAndRemove( &aWordToDelete );
          if( xFoundEntry )
          {
              if( !xFoundEntry->IsTextOnly() )
              {
                  OUString aName( aWordToDelete.GetShort() );
                  if (xStorage->IsOLEStorage())
                      aName = EncryptBlockName_Imp(aName);
                  else
                      GeneratePackageName ( aWordToDelete.GetShort(), aName );

                  if( xStorage->IsContained( aName ) )
                  {
                      xStorage->Remove( aName );
                      bRet = xStorage->Commit();
                  }
              }
          }
      }

      for (const SvxAutocorrWord & aNewEntrie : aNewEntries)
      {
          SvxAutocorrWord aWordToAdd(aNewEntrie.GetShort(), aNewEntrie.GetLong(), true );
          std::optional<SvxAutocorrWord> xRemoved = pAutocorr_List->FindAndRemove( &aWordToAdd );
          if( xRemoved )
          {
              if( !xRemoved->IsTextOnly() )
              {
                  // Still have to remove the Storage
                  OUString sStorageName( aWordToAdd.GetShort() );
                  if (xStorage->IsOLEStorage())
                      sStorageName = EncryptBlockName_Imp(sStorageName);
                  else
                      GeneratePackageName ( aWordToAdd.GetShort(), sStorageName);

                  if( xStorage->IsContained( sStorageName ) )
                      xStorage->Remove( sStorageName );
              }
          }
          bRet = pAutocorr_List->Insert( std::move(aWordToAdd) );

          if ( !bRet )
          {
              break;
          }
      }

      if ( bRet )
      {
          bRet = MakeBlocklist_Imp( *xStorage );
      }
  }
  return bRet;
2723}
5
←
Potential leak of memory pointed to by 'xStorage.pObj'

2725bool SvxAutoCorrectLanguageLists::PutText( const OUString& rShort, const OUString& rLong )
2726{
  // First get the current list!
  GetAutocorrWordList();

  MakeUserStorage_Impl();
  tools::SvRef<SotStorage> xStg = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );

  bool bRet = xStg.is() && ERRCODE_NONEErrCode(0) == xStg->GetError();

  // Update the word list
  if( bRet )
  {
      SvxAutocorrWord aNew(rShort, rLong, true );
      std::optional<SvxAutocorrWord> xRemove = pAutocorr_List->FindAndRemove( &aNew );
      if( xRemove )
      {
          if( !xRemove->IsTextOnly() )
          {
              // Still have to remove the Storage
              OUString sStgNm( rShort );
              if (xStg->IsOLEStorage())
                  sStgNm = EncryptBlockName_Imp(sStgNm);
              else
                  GeneratePackageName ( rShort, sStgNm);

              if( xStg->IsContained( sStgNm ) )
                  xStg->Remove( sStgNm );
          }
      }

      if( pAutocorr_List->Insert( std::move(aNew) ) )
      {
          bRet = MakeBlocklist_Imp( *xStg );
          xStg = nullptr;
      }
      else
      {
          bRet = false;
      }
  }
  return bRet;
2767}

2769void SvxAutoCorrectLanguageLists::PutText( const OUString& rShort,
                                             SfxObjectShell& rShell )
2771{
  // First get the current list!
  GetAutocorrWordList();

  MakeUserStorage_Impl();

  try
  {
      uno::Reference < embed::XStorage > xStg = comphelper::OStorageHelper::GetStorageFromURL( sUserAutoCorrFile, embed::ElementModes::READWRITE );
      OUString sLong;
      bool bRet = rAutoCorrect.PutText( xStg, sUserAutoCorrFile, rShort, rShell, sLong );
      xStg = nullptr;

      // Update the word list
      if( bRet )
      {
          if( pAutocorr_List->Insert( SvxAutocorrWord(rShort, sLong, false) ) )
          {
              tools::SvRef<SotStorage> xStor = new SotStorage( sUserAutoCorrFile, StreamMode::READWRITE );
              MakeBlocklist_Imp( *xStor );
          }
      }
  }
  catch ( const uno::Exception& )
  {
  }
2797}

2799// Keep the list sorted ...
2800struct SvxAutocorrWordList::CompareSvxAutocorrWordList
2801{
  bool operator()( SvxAutocorrWord const & lhs, SvxAutocorrWord const & rhs ) const
  {
      CollatorWrapper& rCmp = ::GetCollatorWrapper();
      return rCmp.compareString( lhs.GetShort(), rhs.GetShort() ) < 0;
  }
2807};

2809namespace {

2811typedef std::unordered_map<OUString, SvxAutocorrWord> AutocorrWordHashType;

2813}

2815struct SvxAutocorrWordList::Impl
2816{

  // only one of these contains the data
  // maSortedVector is manually sorted so we can optimise data movement
  mutable AutocorrWordSetType maSortedVector;
  mutable AutocorrWordHashType maHash; // key is 'Short'

  void DeleteAndDestroyAll()
  {
      maHash.clear();
      maSortedVector.clear();
  }
2828};

2830SvxAutocorrWordList::SvxAutocorrWordList() : mpImpl(new Impl) {}

2832SvxAutocorrWordList::~SvxAutocorrWordList()
2833{
2834}

2836void SvxAutocorrWordList::DeleteAndDestroyAll()
2837{
  mpImpl->DeleteAndDestroyAll();
2839}

2841// returns true if inserted
2842const SvxAutocorrWord* SvxAutocorrWordList::Insert(SvxAutocorrWord aWord) const
2843{
  if ( mpImpl->maSortedVector.empty() ) // use the hash
  {
      OUString aShort = aWord.GetShort();
      auto [it,inserted] = mpImpl->maHash.emplace( std::move(aShort), std::move(aWord) );
      if (inserted)
          return &(it->second);
      return nullptr;
  }
  else
  {
      auto it = std::lower_bound(mpImpl->maSortedVector.begin(), mpImpl->maSortedVector.end(), aWord, CompareSvxAutocorrWordList());
      CollatorWrapper& rCmp = ::GetCollatorWrapper();
      if (it == mpImpl->maSortedVector.end() || rCmp.compareString( aWord.GetShort(), it->GetShort() ) != 0)
      {
          it = mpImpl->maSortedVector.insert(it, std::move(aWord));
          return &*it;
      }
      return nullptr;
  }
2863}

2865void SvxAutocorrWordList::LoadEntry(const OUString& sWrong, const OUString& sRight, bool bOnlyTxt)
2866{
  (void)Insert(SvxAutocorrWord( sWrong, sRight, bOnlyTxt ));
2868}

2870bool SvxAutocorrWordList::empty() const
2871{
  return mpImpl->maHash.empty() && mpImpl->maSortedVector.empty();
2873}

2875std::optional<SvxAutocorrWord> SvxAutocorrWordList::FindAndRemove(const SvxAutocorrWord *pWord)
2876{

  if ( mpImpl->maSortedVector.empty() ) // use the hash
  {
      AutocorrWordHashType::iterator it = mpImpl->maHash.find( pWord->GetShort() );
      if( it != mpImpl->maHash.end() )
      {
          SvxAutocorrWord pMatch = std::move(it->second);
          mpImpl->maHash.erase (it);
          return pMatch;
      }
  }
  else
  {
      auto it = std::lower_bound(mpImpl->maSortedVector.begin(), mpImpl->maSortedVector.end(), *pWord, CompareSvxAutocorrWordList());
      if (it != mpImpl->maSortedVector.end() && !CompareSvxAutocorrWordList()(*pWord, *it))
      {
          SvxAutocorrWord pMatch = std::move(*it);
          mpImpl->maSortedVector.erase (it);
          return pMatch;
      }
  }
  return std::optional<SvxAutocorrWord>();
2899}

2901// return the sorted contents - defer sorting until we have to.
2902const SvxAutocorrWordList::AutocorrWordSetType& SvxAutocorrWordList::getSortedContent() const
2903{
  // convert from hash to set permanently
  if ( mpImpl->maSortedVector.empty() )
  {
      std::vector<SvxAutocorrWord> tmp;
      tmp.reserve(mpImpl->maHash.size());
      for (auto & rPair : mpImpl->maHash)
          tmp.emplace_back(std::move(rPair.second));
      mpImpl->maHash.clear();
      // sort twice - this gets the list into mostly-sorted order, which
      // reduces the number of times we need to invoke the expensive ICU collate fn.
      std::sort(tmp.begin(), tmp.end(),
          [] ( SvxAutocorrWord const & lhs, SvxAutocorrWord const & rhs )
          {
              return lhs.GetShort() < rhs.GetShort();
          });
      // This beast has some O(N log(N)) in a terribly slow ICU collate fn.
      // stable_sort is twice as fast as sort in this situation because it does
      // fewer comparison operations.
      std::stable_sort(tmp.begin(), tmp.end(), CompareSvxAutocorrWordList());
      mpImpl->maSortedVector = std::move(tmp);
  }
  return mpImpl->maSortedVector;
2926}

2928const SvxAutocorrWord* SvxAutocorrWordList::WordMatches(const SvxAutocorrWord *pFnd,
                                    const OUString &rTxt,
                                    sal_Int32 &rStt,
                                    sal_Int32 nEndPos) const
2932{
  const OUString& rChk = pFnd->GetShort();

  sal_Int32 left_wildcard = rChk.startsWith( ".*" ) ? 2 : 0; // ".*word" pattern?
  sal_Int32 right_wildcard = rChk.endsWith( ".*" ) ? 2 : 0; // "word.*" pattern?
  sal_Int32 nSttWdPos = nEndPos;

  // direct replacement of keywords surrounded by colons (for example, ":name:")
  bool bColonNameColon = rTxt.getLength() > nEndPos &&
      rTxt[nEndPos] == ':' && rChk[0] == ':' && rChk.endsWith(":");
  if ( nEndPos + (bColonNameColon ? 1 : 0) >= rChk.getLength() - left_wildcard - right_wildcard )
  {

      bool bWasWordDelim = false;
      sal_Int32 nCalcStt = nEndPos - rChk.getLength() + left_wildcard;
      if (bColonNameColon)
          nCalcStt++;
      if( !right_wildcard && ( !nCalcStt || nCalcStt == rStt || left_wildcard || bColonNameColon ||
            ( nCalcStt < rStt &&
              IsWordDelim( rTxt[ nCalcStt - 1 ] ))) )
      {
          TransliterationWrapper& rCmp = GetIgnoreTranslWrapper();
          OUString sWord = rTxt.copy(nCalcStt, rChk.getLength() - left_wildcard);
          if( (!left_wildcard && rCmp.isEqual( rChk, sWord )) || (left_wildcard && rCmp.isEqual( rChk.copy(left_wildcard), sWord) ))
          {
              rStt = nCalcStt;
              if (!left_wildcard)
              {
                  // fdo#33899 avoid "1/2", "1/3".. to be replaced by fractions in dates, eg. 1/2/14
                  if (rTxt.getLength() > nEndPos && rTxt[nEndPos] == '/' && rChk.indexOf('/') != -1)
                      return nullptr;
                  return pFnd;
              }
              // get the first word delimiter position before the matching ".*word" pattern
              while( rStt && !(bWasWordDelim = IsWordDelim( rTxt[ --rStt ])))
                  ;
              if (bWasWordDelim) rStt++;
              OUString left_pattern = rTxt.copy(rStt, nEndPos - rStt - rChk.getLength() + left_wildcard);
              // avoid double spaces before simple "word" replacement
              left_pattern += (left_pattern.getLength() == 0 && pFnd->GetLong()[0] == 0x20) ? pFnd->GetLong().copy(1) : pFnd->GetLong();
              if( const SvxAutocorrWord* pNew = Insert( SvxAutocorrWord(rTxt.copy(rStt, nEndPos - rStt), left_pattern) ) )
                  return pNew;
          }
      } else
      // match "word.*" or ".*word.*" patterns, eg. "i18n.*", ".*---.*", TODO: add transliteration support
      if ( right_wildcard )
      {

          OUString sTmp( rChk.copy( left_wildcard, rChk.getLength() - left_wildcard - right_wildcard ) );
          // Get the last word delimiter position
          bool not_suffix;

          while( nSttWdPos && !(bWasWordDelim = IsWordDelim( rTxt[ --nSttWdPos ])))
              ;
          // search the first occurrence (with a left word delimitation, if needed)
          sal_Int32 nFndPos = -1;
          do {
              nFndPos = rTxt.indexOf( sTmp, nFndPos + 1);
              if (nFndPos == -1)
                  break;
              not_suffix = bWasWordDelim && (nSttWdPos >= (nFndPos + sTmp.getLength()));
          } while ( (!left_wildcard && nFndPos && !IsWordDelim( rTxt[ nFndPos - 1 ])) || not_suffix );

          if ( nFndPos != -1 )
          {
              sal_Int32 extra_repl = nFndPos + sTmp.getLength() > nEndPos ? 1: 0; // for patterns with terminating characters, eg. "a:"

              if ( left_wildcard )
              {
                  // get the first word delimiter position before the matching ".*word.*" pattern
                  while( nFndPos && !(bWasWordDelim = IsWordDelim( rTxt[ --nFndPos ])))
                      ;
                  if (bWasWordDelim) nFndPos++;
              }
              if (nEndPos + extra_repl <= nFndPos)
              {
                  return nullptr;
              }
              // store matching pattern and its replacement as a new list item, eg. "i18ns" -> "internationalizations"
              OUString aShort = rTxt.copy(nFndPos, nEndPos - nFndPos + extra_repl);

              OUString aLong;
              rStt = nFndPos;
              if ( !left_wildcard )
              {
                  sal_Int32 siz = nEndPos - nFndPos - sTmp.getLength();
                  aLong = pFnd->GetLong() + (siz > 0 ? rTxt.copy(nFndPos + sTmp.getLength(), siz) : "");
              } else {
                  OUStringBuffer buf;
                  do {
                      nSttWdPos = rTxt.indexOf( sTmp, nFndPos);
                      if (nSttWdPos != -1)
                      {
                          sal_Int32 nTmp(nFndPos);
                          while (nTmp < nSttWdPos && !IsWordDelim(rTxt[nTmp]))
                              nTmp++;
                          if (nTmp < nSttWdPos)
                              break; // word delimiter found
                          buf.append(std::u16string_view(rTxt).substr(nFndPos, nSttWdPos - nFndPos)).append(pFnd->GetLong());
                          nFndPos = nSttWdPos + sTmp.getLength();
                      }
                  } while (nSttWdPos != -1);
                  if (nEndPos - nFndPos > extra_repl)
                      buf.append(std::u16string_view(rTxt).substr(nFndPos, nEndPos - nFndPos));
                  aLong = buf.makeStringAndClear();
              }
              if ( const SvxAutocorrWord* pNew = Insert( SvxAutocorrWord(aShort, aLong) ) )
              {
                  if ( (rTxt.getLength() > nEndPos && IsWordDelim(rTxt[nEndPos])) || rTxt.getLength() == nEndPos )
                      return pNew;
              }
          }
      }
  }
  return nullptr;
3047}

3049const SvxAutocorrWord* SvxAutocorrWordList::SearchWordsInList(const OUString& rTxt, sal_Int32& rStt,
                                                            sal_Int32 nEndPos) const
3051{
  for (auto const& elem : mpImpl->maHash)
  {
      if( const SvxAutocorrWord *pTmp = WordMatches( &elem.second, rTxt, rStt, nEndPos ) )
          return pTmp;
  }

  for (auto const& elem : mpImpl->maSortedVector)
  {
      if( const SvxAutocorrWord *pTmp = WordMatches( &elem, rTxt, rStt, nEndPos ) )
          return pTmp;
  }
  return nullptr;
3064}

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