linguistic/source/dicimp.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <cppuhelper/factory.hxx>
  22 #include "dicimp.hxx"
  23 #include "hyphdsp.hxx"
  24 #include <i18nlangtag/lang.h>
  25 #include <i18nlangtag/languagetag.hxx>
  26 #include <osl/mutex.hxx>
  27 #include <tools/debug.hxx>
  28 #include <tools/stream.hxx>
  29 #include <tools/urlobj.hxx>
  30 #include <comphelper/processfactory.hxx>
  31 #include <comphelper/string.hxx>
  32 #include <comphelper/sequence.hxx>
  33 #include <unotools/ucbstreamhelper.hxx>
  34
  35 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  36 #include <com/sun/star/linguistic2/DictionaryType.hpp>
  37 #include <com/sun/star/linguistic2/DictionaryEventFlags.hpp>
  38 #include <com/sun/star/registry/XRegistryKey.hpp>
  39 #include <com/sun/star/io/TempFile.hpp>
  40 #include <com/sun/star/io/XInputStream.hpp>
  41 #include <com/sun/star/io/XOutputStream.hpp>
  42
  43 #include <com/sun/star/linguistic2/LinguServiceManager.hpp>
  44 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
  45
  46 #include "defs.hxx"
  47
  48 #include <algorithm>
  49
  50
  51 using namespace utl;
  52 using namespace osl;
  53 using namespace com::sun::star;
  54 using namespace com::sun::star::lang;
  55 using namespace com::sun::star::uno;
  56 using namespace com::sun::star::linguistic2;
  57 using namespace linguistic;
  58
  59
  60 #define BUFSIZE             4096
  61 #define VERS2_NOLANGUAGE    1024
  62
  63 #define MAX_HEADER_LENGTH 16
  64
  65 // XML-header to query SPELLML support
  66 // to handle user words with "Grammar By" model words
  67 #define SPELLML_SUPPORT "<?xml?>"
  68
  69 // User dictionaries can contain optional "title:" tags
  70 // to support custom titles with space and other characters.
  71 // (old mechanism stores the title of the user dictionary
  72 // only in its file name, but special characters are
  73 // problem for user dictionaries shipped with LibreOffice).
  74 //
  75 // The following fake file name extension will be
  76 // added to the text of the title: field for correct
  77 // text stripping and dictionary saving.
  78 #define EXTENSION_FOR_TITLE_TEXT "."
  79
  80 static const sal_Char* const pVerStr2    = "WBSWG2";
  81 static const sal_Char* const pVerStr5    = "WBSWG5";
  82 static const sal_Char* const pVerStr6    = "WBSWG6";
  83 static const sal_Char* const pVerOOo7    = "OOoUserDict1";
  84
  85 static const sal_Int16 DIC_VERSION_DONTKNOW = -1;
  86 static const sal_Int16 DIC_VERSION_2 = 2;
  87 static const sal_Int16 DIC_VERSION_5 = 5;
  88 static const sal_Int16 DIC_VERSION_6 = 6;
  89 static const sal_Int16 DIC_VERSION_7 = 7;
  90
  91 static uno::Reference< XLinguServiceManager2 > GetLngSvcMgr_Impl()
  92 {
  93     uno::Reference< XComponentContext > xContext( comphelper::getProcessComponentContext() );
  94     uno::Reference< XLinguServiceManager2 > xRes = LinguServiceManager::create( xContext ) ;
  95     return xRes;
  96 }
  97
  98 static bool getTag(const OString &rLine, const sal_Char *pTagName,
  99     OString &rTagValue)
 100 {
 101     sal_Int32 nPos = rLine.indexOf(pTagName);
 102     if (nPos == -1)
 103         return false;
 104
 105     rTagValue = comphelper::string::strip(rLine.copy(nPos + rtl_str_getLength(pTagName)),
 106         ' ');
 107     return true;
 108 }
 109
 110
 111 sal_Int16 ReadDicVersion( SvStreamPtr const &rpStream, LanguageType &nLng, bool &bNeg, OUString &aDicName )
 112 {
 113     // Sniff the header
 114     sal_Int16 nDicVersion = DIC_VERSION_DONTKNOW;
 115     sal_Char pMagicHeader[MAX_HEADER_LENGTH];
 116
 117     nLng = LANGUAGE_NONE;
 118     bNeg = false;
 119
 120     if (!rpStream.get() || rpStream->GetError())
 121         return -1;
 122
 123     sal_uInt64 const nSniffPos = rpStream->Tell();
 124     static std::size_t nVerOOo7Len = sal::static_int_cast< std::size_t >(strlen( pVerOOo7 ));
 125     pMagicHeader[ nVerOOo7Len ] = '\0';
 126     if ((rpStream->ReadBytes(static_cast<void *>(pMagicHeader), nVerOOo7Len) == nVerOOo7Len) &&
 127         !strcmp(pMagicHeader, pVerOOo7))
 128     {
 129         bool bSuccess;
 130         OString aLine;
 131
 132         nDicVersion = DIC_VERSION_7;
 133
 134         // 1st skip magic / header line
 135         rpStream->ReadLine(aLine);
 136
 137         // 2nd line: language all | en-US | pt-BR ...
 138         while ((bSuccess = rpStream->ReadLine(aLine)))
 139         {
 140             OString aTagValue;
 141
 142             if (aLine[0] == '#') // skip comments
 143                 continue;
 144
 145             // lang: field
 146             if (getTag(aLine, "lang: ", aTagValue))
 147             {
 148                 if (aTagValue == "<none>")
 149                     nLng = LANGUAGE_NONE;
 150                 else
 151                     nLng = LanguageTag::convertToLanguageType(
 152                             OStringToOUString( aTagValue, RTL_TEXTENCODING_ASCII_US));
 153             }
 154
 155             // type: negative / positive
 156             if (getTag(aLine, "type: ", aTagValue))
 157             {
 158                 bNeg = aTagValue == "negative";
 159             }
 160
 161             // lang: title
 162             if (getTag(aLine, "title: ", aTagValue))
 163             {
 164                 aDicName = OStringToOUString( aTagValue, RTL_TEXTENCODING_UTF8) +
 165                     // recent title text preparation in GetDicInfoStr() waits for an
 166                     // extension, so we add it to avoid bad stripping at final dot
 167                     // of the title text
 168                     EXTENSION_FOR_TITLE_TEXT;
 169             }
 170
 171             if (aLine.indexOf("---") != -1) // end of header
 172                 break;
 173         }
 174         if (!bSuccess)
 175             return -2;
 176     }
 177     else
 178     {
 179         sal_uInt16 nLen;
 180
 181         rpStream->Seek (nSniffPos );
 182
 183         rpStream->ReadUInt16( nLen );
 184         if (nLen >= MAX_HEADER_LENGTH)
 185             return -1;
 186
 187         rpStream->ReadBytes(pMagicHeader, nLen);
 188         pMagicHeader[nLen] = '\0';
 189
 190         // Check version magic
 191         if (0 == strcmp( pMagicHeader, pVerStr6 ))
 192             nDicVersion = DIC_VERSION_6;
 193         else if (0 == strcmp( pMagicHeader, pVerStr5 ))
 194             nDicVersion = DIC_VERSION_5;
 195         else if (0 == strcmp( pMagicHeader, pVerStr2 ))
 196             nDicVersion = DIC_VERSION_2;
 197         else
 198             nDicVersion = DIC_VERSION_DONTKNOW;
 199
 200         if (DIC_VERSION_2 == nDicVersion ||
 201             DIC_VERSION_5 == nDicVersion ||
 202             DIC_VERSION_6 == nDicVersion)
 203         {
 204             // The language of the dictionary
 205             sal_uInt16 nTmp = 0;
 206             rpStream->ReadUInt16( nTmp );
 207             nLng = LanguageType(nTmp);
 208             if (VERS2_NOLANGUAGE == static_cast<sal_uInt16>(nLng))
 209                 nLng = LANGUAGE_NONE;
 210
 211             // Negative Flag
 212             rpStream->ReadCharAsBool( bNeg );
 213         }
 214     }
 215
 216     return nDicVersion;
 217 }
 218
 219 DictionaryNeo::DictionaryNeo(const OUString &rName,
 220                              LanguageType nLang, DictionaryType eType,
 221                              const OUString &rMainURL,
 222                              bool bWriteable) :
 223     aDicEvtListeners( GetLinguMutex() ),
 224     aDicName        (rName),
 225     aMainURL        (rMainURL),
 226     eDicType        (eType),
 227     nLanguage       (nLang)
 228 {
 229     nDicVersion  = DIC_VERSION_DONTKNOW;
 230     bNeedEntries = true;
 231     bIsModified  = bIsActive = false;
 232     bIsReadonly = !bWriteable;
 233
 234     if( !rMainURL.isEmpty())
 235     {
 236         bool bExists = FileExists( rMainURL );
 237         if( !bExists )
 238         {
 239             // save new dictionaries with in Format 7 (UTF8 plain text)
 240             nDicVersion  = DIC_VERSION_7;
 241
 242             //! create physical representation of an **empty** dictionary
 243             //! that could be found by the dictionary-list implementation
 244             // (Note: empty dictionaries are not just empty files!)
 245             DBG_ASSERT( !bIsReadonly,
 246                     "DictionaryNeo: dictionaries should be writeable if they are to be saved" );
 247             if (!bIsReadonly)
 248                 saveEntries( rMainURL );
 249             bNeedEntries = false;
 250         }
 251     }
 252     else
 253     {
 254         // non persistent dictionaries (like IgnoreAllList) should always be writable
 255         bIsReadonly  = false;
 256         bNeedEntries = false;
 257     }
 258 }
 259
 260 DictionaryNeo::~DictionaryNeo()
 261 {
 262 }
 263
 264 ErrCode DictionaryNeo::loadEntries(const OUString &rMainURL)
 265 {
 266     MutexGuard  aGuard( GetLinguMutex() );
 267
 268     // counter check that it is safe to set bIsModified to sal_False at
 269     // the end of the function
 270     DBG_ASSERT(!bIsModified, "lng : dictionary already modified!");
 271
 272     // function should only be called once in order to load entries from file
 273     bNeedEntries = false;
 274
 275     if (rMainURL.isEmpty())
 276         return ERRCODE_NONE;
 277
 278     uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );
 279
 280     // get XInputStream stream
 281     uno::Reference< io::XInputStream > xStream;
 282     try
 283     {
 284         uno::Reference< ucb::XSimpleFileAccess3 > xAccess( ucb::SimpleFileAccess::create(xContext) );
 285         xStream = xAccess->openFileRead( rMainURL );
 286     }
 287     catch (const uno::Exception &)
 288     {
 289         SAL_WARN( "linguistic", "failed to get input stream" );
 290     }
 291     if (!xStream.is())
 292         return ErrCode(sal_uInt32(-1));
 293
 294     SvStreamPtr pStream = SvStreamPtr( utl::UcbStreamHelper::CreateStream( xStream ) );
 295
 296     // read header
 297     bool bNegativ;
 298     LanguageType nLang;
 299     nDicVersion = ReadDicVersion(pStream, nLang, bNegativ, aDicName);
 300     ErrCode nErr = pStream->GetError();
 301     if (nErr != ERRCODE_NONE)
 302         return nErr;
 303
 304     nLanguage = nLang;
 305
 306     eDicType = bNegativ ? DictionaryType_NEGATIVE : DictionaryType_POSITIVE;
 307
 308     rtl_TextEncoding eEnc = osl_getThreadTextEncoding();
 309     if (nDicVersion >= DIC_VERSION_6)
 310         eEnc = RTL_TEXTENCODING_UTF8;
 311     aEntries.clear();
 312
 313     if (DIC_VERSION_6 == nDicVersion ||
 314         DIC_VERSION_5 == nDicVersion ||
 315         DIC_VERSION_2 == nDicVersion)
 316     {
 317         sal_uInt16  nLen = 0;
 318         sal_Char aWordBuf[ BUFSIZE ];
 319
 320         // Read the first word
 321         if (!pStream->eof())
 322         {
 323             pStream->ReadUInt16( nLen );
 324             if (ERRCODE_NONE != (nErr = pStream->GetError()))
 325                 return nErr;
 326             if ( nLen < BUFSIZE )
 327             {
 328                 pStream->ReadBytes(aWordBuf, nLen);
 329                 if (ERRCODE_NONE != (nErr = pStream->GetError()))
 330                     return nErr;
 331                 *(aWordBuf + nLen) = 0;
 332             }
 333             else
 334                 return SVSTREAM_READ_ERROR;
 335         }
 336
 337         while(!pStream->eof())
 338         {
 339             // Read from file
 340             // Paste in dictionary without converting
 341             if(*aWordBuf)
 342             {
 343                 OUString aText(aWordBuf, rtl_str_getLength(aWordBuf), eEnc);
 344                 uno::Reference< XDictionaryEntry > xEntry =
 345                         new DicEntry( aText, bNegativ );
 346                 addEntry_Impl( xEntry, true ); //! don't launch events here
 347             }
 348
 349             pStream->ReadUInt16( nLen );
 350             if (pStream->eof())
 351                 break;
 352             if (ERRCODE_NONE != (nErr = pStream->GetError()))
 353                 return nErr;
 354
 355             if (nLen < BUFSIZE)
 356             {
 357                 pStream->ReadBytes(aWordBuf, nLen);
 358                 if (ERRCODE_NONE != (nErr = pStream->GetError()))
 359                     return nErr;
 360             }
 361             else
 362                 return SVSTREAM_READ_ERROR;
 363             *(aWordBuf + nLen) = 0;
 364         }
 365     }
 366     else if (DIC_VERSION_7 == nDicVersion)
 367     {
 368         OString aLine;
 369
 370         // remaining lines - stock strings (a [==] b)
 371         while (pStream->ReadLine(aLine))
 372         {
 373             if (aLine.isEmpty() || aLine[0] == '#') // skip comments
 374                 continue;
 375             OUString aText = OStringToOUString(aLine, RTL_TEXTENCODING_UTF8);
 376             uno::Reference< XDictionaryEntry > xEntry =
 377                     new DicEntry( aText, eDicType == DictionaryType_NEGATIVE );
 378             addEntry_Impl( xEntry, true ); //! don't launch events here
 379         }
 380     }
 381
 382     SAL_WARN_IF(!isSorted(), "linguistic", "dictionary is not sorted");
 383
 384     // since this routine should be called only initially (prior to any
 385     // modification to be saved) we reset the bIsModified flag here that
 386     // was implicitly set by addEntry_Impl
 387     bIsModified = false;
 388
 389     return pStream->GetError();
 390 }
 391
 392 static OString formatForSave(const uno::Reference< XDictionaryEntry > &xEntry,
 393     rtl_TextEncoding eEnc )
 394 {
 395    OStringBuffer aStr(OUStringToOString(xEntry->getDictionaryWord(), eEnc));
 396
 397    if (xEntry->isNegative() || !xEntry->getReplacementText().isEmpty())
 398    {
 399        aStr.append("==");
 400        aStr.append(OUStringToOString(xEntry->getReplacementText(), eEnc));
 401    }
 402    return aStr.makeStringAndClear();
 403 }
 404
 405 ErrCode DictionaryNeo::saveEntries(const OUString &rURL)
 406 {
 407     MutexGuard aGuard( GetLinguMutex() );
 408
 409     if (rURL.isEmpty())
 410         return ERRCODE_NONE;
 411     DBG_ASSERT(!INetURLObject( rURL ).HasError(), "lng : invalid URL");
 412
 413     uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );
 414
 415     // get XOutputStream stream
 416     uno::Reference<io::XStream> xStream;
 417     try
 418     {
 419         xStream = io::TempFile::create(xContext);
 420     }
 421     catch (const uno::Exception &)
 422     {
 423         DBG_ASSERT( false, "failed to get input stream" );
 424     }
 425     if (!xStream.is())
 426         return ErrCode(sal_uInt32(-1));
 427
 428     SvStreamPtr pStream = SvStreamPtr( utl::UcbStreamHelper::CreateStream( xStream ) );
 429
 430     // Always write as the latest version, i.e. DIC_VERSION_7
 431
 432     rtl_TextEncoding eEnc = RTL_TEXTENCODING_UTF8;
 433     pStream->WriteLine(OString(pVerOOo7));
 434     ErrCode nErr = pStream->GetError();
 435     if (nErr != ERRCODE_NONE)
 436         return nErr;
 437     /* XXX: the <none> case could be differentiated, is it absence or
 438      * undetermined or multiple? Earlier versions did not know about 'und' and
 439      * 'mul' and 'zxx' codes. Sync with ReadDicVersion() */
 440     if (LinguIsUnspecified(nLanguage))
 441         pStream->WriteLine(OString("lang: <none>"));
 442     else
 443     {
 444         OStringBuffer aLine("lang: ");
 445         aLine.append(OUStringToOString(LanguageTag::convertToBcp47(nLanguage), eEnc));
 446         pStream->WriteLine(aLine.makeStringAndClear());
 447     }
 448     if (ERRCODE_NONE != (nErr = pStream->GetError()))
 449         return nErr;
 450     if (eDicType == DictionaryType_POSITIVE)
 451         pStream->WriteLine(OString("type: positive"));
 452     else
 453         pStream->WriteLine(OString("type: negative"));
 454     if (aDicName.endsWith(EXTENSION_FOR_TITLE_TEXT))
 455     {
 456         pStream->WriteLine(OUStringToOString("title: " +
 457             // strip EXTENSION_FOR_TITLE_TEXT
 458             aDicName.copy(0, aDicName.lastIndexOf(EXTENSION_FOR_TITLE_TEXT)), eEnc));
 459     }
 460     if (ERRCODE_NONE != (nErr = pStream->GetError()))
 461         return nErr;
 462     pStream->WriteLine(OString("---"));
 463     if (ERRCODE_NONE != (nErr = pStream->GetError()))
 464         return nErr;
 465     for (Reference<XDictionaryEntry> & aEntrie : aEntries)
 466     {
 467         OString aOutStr = formatForSave(aEntrie, eEnc);
 468         pStream->WriteLine (aOutStr);
 469         if (ERRCODE_NONE != (nErr = pStream->GetError()))
 470             return nErr;
 471     }
 472
 473     try
 474     {
 475         pStream.reset();
 476         uno::Reference< ucb::XSimpleFileAccess3 > xAccess(ucb::SimpleFileAccess::create(xContext));
 477         Reference<io::XInputStream> xInputStream(xStream, UNO_QUERY_THROW);
 478         uno::Reference<io::XSeekable> xSeek(xInputStream, UNO_QUERY_THROW);
 479         xSeek->seek(0);
 480         xAccess->writeFile(rURL, xInputStream);
 481         //If we are migrating from an older version, then on first successful
 482         //write, we're now converted to the latest version, i.e. DIC_VERSION_7
 483         nDicVersion = DIC_VERSION_7;
 484     }
 485     catch (const uno::Exception &)
 486     {
 487         DBG_ASSERT( false, "failed to write stream" );
 488         return ErrCode(sal_uInt32(-1));
 489     }
 490
 491     return nErr;
 492 }
 493
 494 void DictionaryNeo::launchEvent(sal_Int16 nEvent,
 495                                 const uno::Reference< XDictionaryEntry >& xEntry)
 496 {
 497     MutexGuard  aGuard( GetLinguMutex() );
 498
 499     DictionaryEvent aEvt;
 500     aEvt.Source = uno::Reference< XDictionary >( this );
 501     aEvt.nEvent = nEvent;
 502     aEvt.xDictionaryEntry = xEntry;
 503
 504     aDicEvtListeners.notifyEach( &XDictionaryEventListener::processDictionaryEvent, aEvt);
 505 }
 506
 507 int DictionaryNeo::cmpDicEntry(const OUString& rWord1,
 508                                const OUString &rWord2,
 509                                bool bSimilarOnly)
 510 {
 511     MutexGuard  aGuard( GetLinguMutex() );
 512
 513     // returns 0 if rWord1 is equal to rWord2
 514     //   "     a value < 0 if rWord1 is less than rWord2
 515     //   "     a value > 0 if rWord1 is greater than rWord2
 516
 517     int nRes = 0;
 518
 519     sal_Int32     nLen1 = rWord1.getLength(),
 520                   nLen2 = rWord2.getLength();
 521     if (bSimilarOnly)
 522     {
 523         const sal_Unicode cChar = '.';
 524         if (nLen1  &&  cChar == rWord1[ nLen1 - 1 ])
 525             nLen1--;
 526         if (nLen2  &&  cChar == rWord2[ nLen2 - 1 ])
 527             nLen2--;
 528     }
 529
 530     const sal_Unicode cIgnChar = '=';
 531     const sal_Unicode cIgnBeg = '['; // for alternative hyphenation, eg. Schif[f]fahrt, Zuc[1k]ker
 532     const sal_Unicode cIgnEnd = ']'; // planned: gee"[1-/e]rfde or ge[-/1e]e"rfde (gee"rfde -> ge=erfde)
 533     sal_Int32       nIdx1 = 0,
 534                   nIdx2 = 0,
 535                   nNumIgnChar1 = 0,
 536                   nNumIgnChar2 = 0;
 537
 538     bool IgnState;
 539     sal_Int32 nDiff = 0;
 540     sal_Unicode cChar1 = '\0';
 541     sal_Unicode cChar2 = '\0';
 542     do
 543     {
 544         // skip chars to be ignored
 545         IgnState = false;
 546         while (nIdx1 < nLen1  &&  ((cChar1 = rWord1[ nIdx1 ]) == cIgnChar || cChar1 == cIgnBeg || IgnState ))
 547         {
 548             if ( cChar1 == cIgnBeg )
 549                 IgnState = true;
 550             else if (cChar1 == cIgnEnd)
 551                 IgnState = false;
 552             nIdx1++;
 553             nNumIgnChar1++;
 554         }
 555         IgnState = false;
 556         while (nIdx2 < nLen2  &&  ((cChar2 = rWord2[ nIdx2 ]) == cIgnChar || cChar2 == cIgnBeg || IgnState ))
 557         {
 558             if ( cChar2 == cIgnBeg )
 559                 IgnState = true;
 560             else if (cChar2 == cIgnEnd)
 561                 IgnState = false;
 562             nIdx2++;
 563             nNumIgnChar2++;
 564         }
 565
 566         if (nIdx1 < nLen1  &&  nIdx2 < nLen2)
 567         {
 568             nDiff = cChar1 - cChar2;
 569             if (nDiff)
 570                 break;
 571             nIdx1++;
 572             nIdx2++;
 573         }
 574     } while (nIdx1 < nLen1  &&  nIdx2 < nLen2);
 575
 576
 577     if (nDiff)
 578         nRes = nDiff;
 579     else
 580     {   // the string with the smallest count of not ignored chars is the
 581         // shorter one
 582
 583         // count remaining IgnChars
 584         IgnState = false;
 585         while (nIdx1 < nLen1 )
 586         {
 587             if (rWord1[ nIdx1 ] == cIgnBeg)
 588                 IgnState = true;
 589             if (IgnState || rWord1[ nIdx1 ] == cIgnChar)
 590                 nNumIgnChar1++;
 591             if (rWord1[ nIdx1] == cIgnEnd)
 592                 IgnState = false;
 593             nIdx1++;
 594         }
 595         IgnState = false;
 596         while (nIdx2 < nLen2 )
 597         {
 598             if (rWord2[ nIdx2 ] == cIgnBeg)
 599                 IgnState = true;
 600             if (IgnState || rWord2[ nIdx2 ] == cIgnChar)
 601                 nNumIgnChar2++;
 602             if (rWord2[ nIdx2 ] == cIgnEnd)
 603                 IgnState = false;
 604             nIdx2++;
 605         }
 606
 607         nRes = (nLen1 - nNumIgnChar1) - (nLen2 - nNumIgnChar2);
 608     }
 609
 610     return nRes;
 611 }
 612
 613 bool DictionaryNeo::seekEntry(const OUString &rWord,
 614                               sal_Int32 *pPos, bool bSimilarOnly)
 615 {
 616     // look for entry with binary search.
 617     // return sal_True if found sal_False else.
 618     // if pPos != NULL it will become the position of the found entry, or
 619     // if that was not found the position where it has to be inserted
 620     // to keep the entries sorted
 621
 622     MutexGuard  aGuard( GetLinguMutex() );
 623
 624     sal_Int32 nUpperIdx = getCount(),
 625           nMidIdx,
 626           nLowerIdx = 0;
 627     if( nUpperIdx > 0 )
 628     {
 629         nUpperIdx--;
 630         while( nLowerIdx <= nUpperIdx )
 631         {
 632             nMidIdx = (nLowerIdx + nUpperIdx) / 2;
 633             DBG_ASSERT(aEntries[nMidIdx].is(), "lng : empty entry encountered");
 634
 635             int nCmp = - cmpDicEntry( aEntries[nMidIdx]->getDictionaryWord(),
 636                                       rWord, bSimilarOnly );
 637             if(nCmp == 0)
 638             {
 639                 if( pPos ) *pPos = nMidIdx;
 640                 return true;
 641             }
 642             else if(nCmp > 0)
 643                 nLowerIdx = nMidIdx + 1;
 644             else if( nMidIdx == 0 )
 645             {
 646                 if( pPos ) *pPos = nLowerIdx;
 647                 return false;
 648             }
 649             else
 650                 nUpperIdx = nMidIdx - 1;
 651         }
 652     }
 653     if( pPos ) *pPos = nLowerIdx;
 654     return false;
 655 }
 656
 657 bool DictionaryNeo::isSorted()
 658 {
 659     bool bRes = true;
 660
 661     sal_Int32 nEntries = getCount();
 662     sal_Int32 i;
 663     for (i = 1;  i < nEntries;  i++)
 664     {
 665         if (cmpDicEntry( aEntries[i-1]->getDictionaryWord(),
 666                          aEntries[i]->getDictionaryWord() ) > 0)
 667         {
 668             bRes = false;
 669             break;
 670         }
 671     }
 672     return bRes;
 673 }
 674
 675 bool DictionaryNeo::addEntry_Impl(const uno::Reference< XDictionaryEntry >& xDicEntry,
 676         bool bIsLoadEntries)
 677 {
 678     MutexGuard  aGuard( GetLinguMutex() );
 679
 680     bool bRes = false;
 681
 682     if ( bIsLoadEntries || (!bIsReadonly  &&  xDicEntry.is()) )
 683     {
 684         bool bIsNegEntry = xDicEntry->isNegative();
 685         bool bAddEntry   = !isFull() &&
 686                    (   ( eDicType == DictionaryType_POSITIVE && !bIsNegEntry )
 687                     || ( eDicType == DictionaryType_NEGATIVE &&  bIsNegEntry )
 688                     || ( eDicType == DictionaryType_MIXED ) );
 689
 690         // look for position to insert entry at
 691         // if there is already an entry do not insert the new one
 692         sal_Int32 nPos = 0;
 693         if (bAddEntry)
 694         {
 695             const bool bFound = seekEntry( xDicEntry->getDictionaryWord(), &nPos );
 696             if (bFound)
 697                 bAddEntry = false;
 698         }
 699
 700         if (bAddEntry)
 701         {
 702             DBG_ASSERT(!bNeedEntries, "lng : entries still not loaded");
 703
 704             // insert new entry at specified position
 705             aEntries.insert(aEntries.begin() + nPos, xDicEntry);
 706             SAL_WARN_IF(!isSorted(), "linguistic", "dictionary entries unsorted");
 707
 708             bIsModified = true;
 709             bRes = true;
 710
 711             if (!bIsLoadEntries)
 712                 launchEvent( DictionaryEventFlags::ADD_ENTRY, xDicEntry );
 713         }
 714     }
 715
 716     // add word to the Hunspell dictionary using a sample word for affixation/compounding
 717     if (xDicEntry.is() && !xDicEntry->isNegative() && !xDicEntry->getReplacementText().isEmpty()) {
 718         uno::Reference< XLinguServiceManager2 > xLngSvcMgr( GetLngSvcMgr_Impl() );
 719         uno::Reference< XSpellChecker1 > xSpell;
 720         Reference< XSpellAlternatives > xTmpRes;
 721         xSpell.set( xLngSvcMgr->getSpellChecker(), UNO_QUERY );
 722         Sequence< css::beans::PropertyValue > aEmptySeq;
 723         if (xSpell.is() && (xSpell->isValid( SPELLML_SUPPORT, static_cast<sal_uInt16>(nLanguage), aEmptySeq )))
 724         {
 725             // "Grammar By" sample word is a Hunspell dictionary word?
 726             if (xSpell->isValid( xDicEntry->getReplacementText(), static_cast<sal_uInt16>(nLanguage), aEmptySeq ))
 727             {
 728                 xTmpRes = xSpell->spell( "<?xml?><query type='add'><word>" +
 729                     xDicEntry->getDictionaryWord() + "</word><word>" + xDicEntry->getReplacementText() +
 730                     "</word></query>", static_cast<sal_uInt16>(nLanguage), aEmptySeq );
 731                 bRes = true;
 732             } else
 733                 bRes = false;
 734         }
 735     }
 736
 737     return bRes;
 738 }
 739
 740 OUString SAL_CALL DictionaryNeo::getName(  )
 741 {
 742     MutexGuard  aGuard( GetLinguMutex() );
 743     return aDicName;
 744 }
 745
 746 void SAL_CALL DictionaryNeo::setName( const OUString& aName )
 747 {
 748     MutexGuard  aGuard( GetLinguMutex() );
 749
 750     if (aDicName != aName)
 751     {
 752         aDicName = aName;
 753         launchEvent(DictionaryEventFlags::CHG_NAME, nullptr);
 754     }
 755 }
 756
 757 DictionaryType SAL_CALL DictionaryNeo::getDictionaryType(  )
 758 {
 759     MutexGuard  aGuard( GetLinguMutex() );
 760
 761     return eDicType;
 762 }
 763
 764 void SAL_CALL DictionaryNeo::setActive( sal_Bool bActivate )
 765 {
 766     MutexGuard  aGuard( GetLinguMutex() );
 767
 768     if (bIsActive != bool(bActivate))
 769     {
 770         bIsActive = bActivate;
 771         sal_Int16 nEvent = bIsActive ?
 772                 DictionaryEventFlags::ACTIVATE_DIC : DictionaryEventFlags::DEACTIVATE_DIC;
 773
 774         // remove entries from memory if dictionary is deactivated
 775         if (!bIsActive)
 776         {
 777             bool bIsEmpty = aEntries.empty();
 778
 779             // save entries first if necessary
 780             if (bIsModified && hasLocation() && !isReadonly())
 781             {
 782                 store();
 783
 784                 aEntries.clear();
 785                 bNeedEntries = !bIsEmpty;
 786             }
 787             DBG_ASSERT( !bIsModified || !hasLocation() || isReadonly(),
 788                     "lng : dictionary is still modified" );
 789         }
 790
 791         launchEvent(nEvent, nullptr);
 792     }
 793 }
 794
 795 sal_Bool SAL_CALL DictionaryNeo::isActive(  )
 796 {
 797     MutexGuard  aGuard( GetLinguMutex() );
 798     return bIsActive;
 799 }
 800
 801 sal_Int32 SAL_CALL DictionaryNeo::getCount(  )
 802 {
 803     MutexGuard  aGuard( GetLinguMutex() );
 804
 805     if (bNeedEntries)
 806         loadEntries( aMainURL );
 807     return static_cast<sal_Int32>(aEntries.size());
 808 }
 809
 810 Locale SAL_CALL DictionaryNeo::getLocale(  )
 811 {
 812     MutexGuard  aGuard( GetLinguMutex() );
 813     return LanguageTag::convertToLocale( nLanguage );
 814 }
 815
 816 void SAL_CALL DictionaryNeo::setLocale( const Locale& aLocale )
 817 {
 818     MutexGuard  aGuard( GetLinguMutex() );
 819     LanguageType nLanguageP = LinguLocaleToLanguage( aLocale );
 820     if (!bIsReadonly  &&  nLanguage != nLanguageP)
 821     {
 822         nLanguage = nLanguageP;
 823         bIsModified = true; // new language needs to be saved with dictionary
 824
 825         launchEvent( DictionaryEventFlags::CHG_LANGUAGE, nullptr );
 826     }
 827 }
 828
 829 uno::Reference< XDictionaryEntry > SAL_CALL DictionaryNeo::getEntry(
 830             const OUString& aWord )
 831 {
 832     MutexGuard  aGuard( GetLinguMutex() );
 833
 834     if (bNeedEntries)
 835         loadEntries( aMainURL );
 836
 837     sal_Int32 nPos;
 838     bool bFound = seekEntry( aWord, &nPos, true );
 839     DBG_ASSERT(!bFound || nPos < static_cast<sal_Int32>(aEntries.size()), "lng : index out of range");
 840
 841     return bFound ? aEntries[ nPos ]
 842                     : uno::Reference< XDictionaryEntry >();
 843 }
 844
 845 sal_Bool SAL_CALL DictionaryNeo::addEntry(
 846             const uno::Reference< XDictionaryEntry >& xDicEntry )
 847 {
 848     MutexGuard  aGuard( GetLinguMutex() );
 849
 850     bool bRes = false;
 851
 852     if (!bIsReadonly)
 853     {
 854         if (bNeedEntries)
 855             loadEntries( aMainURL );
 856         bRes = addEntry_Impl( xDicEntry );
 857     }
 858
 859     return bRes;
 860 }
 861
 862 sal_Bool SAL_CALL
 863     DictionaryNeo::add( const OUString& rWord, sal_Bool bIsNegative,
 864             const OUString& rRplcText )
 865 {
 866     MutexGuard  aGuard( GetLinguMutex() );
 867
 868     bool bRes = false;
 869
 870     if (!bIsReadonly)
 871     {
 872         uno::Reference< XDictionaryEntry > xEntry =
 873                 new DicEntry( rWord, bIsNegative, rRplcText );
 874         bRes = addEntry_Impl( xEntry );
 875     }
 876
 877     return bRes;
 878 }
 879
 880 sal_Bool SAL_CALL DictionaryNeo::remove( const OUString& aWord )
 881 {
 882     MutexGuard  aGuard( GetLinguMutex() );
 883
 884     bool bRemoved = false;
 885
 886     if (!bIsReadonly)
 887     {
 888         if (bNeedEntries)
 889             loadEntries( aMainURL );
 890
 891         sal_Int32 nPos;
 892         bool bFound = seekEntry( aWord, &nPos );
 893         DBG_ASSERT(!bFound || nPos < static_cast<sal_Int32>(aEntries.size()), "lng : index out of range");
 894
 895         // remove element if found
 896         if (bFound)
 897         {
 898             // entry to be removed
 899             uno::Reference< XDictionaryEntry >
 900                     xDicEntry( aEntries[ nPos ] );
 901             DBG_ASSERT(xDicEntry.is(), "lng : dictionary entry is NULL");
 902
 903             aEntries.erase(aEntries.begin() + nPos);
 904
 905             bRemoved = bIsModified = true;
 906
 907             launchEvent( DictionaryEventFlags::DEL_ENTRY, xDicEntry );
 908         }
 909     }
 910
 911     return bRemoved;
 912 }
 913
 914 sal_Bool SAL_CALL DictionaryNeo::isFull(  )
 915 {
 916     MutexGuard  aGuard( GetLinguMutex() );
 917
 918     if (bNeedEntries)
 919         loadEntries( aMainURL );
 920     return aEntries.size() >= DIC_MAX_ENTRIES;
 921 }
 922
 923 uno::Sequence< uno::Reference< XDictionaryEntry > >
 924     SAL_CALL DictionaryNeo::getEntries(  )
 925 {
 926     MutexGuard  aGuard( GetLinguMutex() );
 927
 928     if (bNeedEntries)
 929         loadEntries( aMainURL );
 930     return comphelper::containerToSequence(aEntries);
 931 }
 932
 933
 934 void SAL_CALL DictionaryNeo::clear(  )
 935 {
 936     MutexGuard  aGuard( GetLinguMutex() );
 937
 938     if (!bIsReadonly && !aEntries.empty())
 939     {
 940         // release all references to old entries
 941         aEntries.clear();
 942
 943         bNeedEntries = false;
 944         bIsModified = true;
 945
 946         launchEvent( DictionaryEventFlags::ENTRIES_CLEARED , nullptr );
 947     }
 948 }
 949
 950 sal_Bool SAL_CALL DictionaryNeo::addDictionaryEventListener(
 951             const uno::Reference< XDictionaryEventListener >& xListener )
 952 {
 953     MutexGuard  aGuard( GetLinguMutex() );
 954
 955     bool bRes = false;
 956     if (xListener.is())
 957     {
 958         sal_Int32   nLen = aDicEvtListeners.getLength();
 959         bRes = aDicEvtListeners.addInterface( xListener ) != nLen;
 960     }
 961     return bRes;
 962 }
 963
 964 sal_Bool SAL_CALL DictionaryNeo::removeDictionaryEventListener(
 965             const uno::Reference< XDictionaryEventListener >& xListener )
 966 {
 967     MutexGuard  aGuard( GetLinguMutex() );
 968
 969     bool bRes = false;
 970     if (xListener.is())
 971     {
 972         sal_Int32   nLen = aDicEvtListeners.getLength();
 973         bRes = aDicEvtListeners.removeInterface( xListener ) != nLen;
 974     }
 975     return bRes;
 976 }
 977
 978
 979 sal_Bool SAL_CALL DictionaryNeo::hasLocation()
 980 {
 981     MutexGuard  aGuard( GetLinguMutex() );
 982     return !aMainURL.isEmpty();
 983 }
 984
 985 OUString SAL_CALL DictionaryNeo::getLocation()
 986 {
 987     MutexGuard  aGuard( GetLinguMutex() );
 988     return aMainURL;
 989 }
 990
 991 sal_Bool SAL_CALL DictionaryNeo::isReadonly()
 992 {
 993     MutexGuard  aGuard( GetLinguMutex() );
 994
 995     return bIsReadonly;
 996 }
 997
 998 void SAL_CALL DictionaryNeo::store()
 999 {
1000     MutexGuard  aGuard( GetLinguMutex() );
1001
1002     if (bIsModified && hasLocation() && !isReadonly())
1003     {
1004         if (!saveEntries( aMainURL ))
1005             bIsModified = false;
1006     }
1007 }
1008
1009 void SAL_CALL DictionaryNeo::storeAsURL(
1010             const OUString& aURL,
1011             const uno::Sequence< beans::PropertyValue >& /*rArgs*/ )
1012 {
1013     MutexGuard  aGuard( GetLinguMutex() );
1014
1015     if (!saveEntries( aURL ))
1016     {
1017         aMainURL = aURL;
1018         bIsModified = false;
1019         bIsReadonly = IsReadOnly( getLocation() );
1020     }
1021 }
1022
1023 void SAL_CALL DictionaryNeo::storeToURL(
1024             const OUString& aURL,
1025             const uno::Sequence< beans::PropertyValue >& /*rArgs*/ )
1026 {
1027     MutexGuard  aGuard( GetLinguMutex() );
1028     saveEntries(aURL);
1029 }
1030
1031
1032 DicEntry::DicEntry(const OUString &rDicFileWord,
1033                    bool bIsNegativWord)
1034 {
1035     if (!rDicFileWord.isEmpty())
1036         splitDicFileWord( rDicFileWord, aDicWord, aReplacement );
1037     bIsNegativ = bIsNegativWord;
1038 }
1039
1040 DicEntry::DicEntry(const OUString &rDicWord, bool bNegativ,
1041                    const OUString &rRplcText) :
1042     aDicWord                (rDicWord),
1043     aReplacement            (rRplcText),
1044     bIsNegativ              (bNegativ)
1045 {
1046 }
1047
1048 DicEntry::~DicEntry()
1049 {
1050 }
1051
1052 void DicEntry::splitDicFileWord(const OUString &rDicFileWord,
1053                                 OUString &rDicWord,
1054                                 OUString &rReplacement)
1055 {
1056     MutexGuard  aGuard( GetLinguMutex() );
1057
1058     sal_Int32 nDelimPos = rDicFileWord.indexOf( "==" );
1059     if (-1 != nDelimPos)
1060     {
1061         sal_Int32 nTriplePos = nDelimPos + 2;
1062         if (    nTriplePos < rDicFileWord.getLength()
1063             &&  rDicFileWord[ nTriplePos ] == '=' )
1064             ++nDelimPos;
1065         rDicWord     = rDicFileWord.copy( 0, nDelimPos );
1066         rReplacement = rDicFileWord.copy( nDelimPos + 2 );
1067     }
1068     else
1069     {
1070         rDicWord     = rDicFileWord;
1071         rReplacement.clear();
1072     }
1073 }
1074
1075 OUString SAL_CALL DicEntry::getDictionaryWord(  )
1076 {
1077     MutexGuard  aGuard( GetLinguMutex() );
1078     return aDicWord;
1079 }
1080
1081 sal_Bool SAL_CALL DicEntry::isNegative(  )
1082 {
1083     MutexGuard  aGuard( GetLinguMutex() );
1084     return bIsNegativ;
1085 }
1086
1087 OUString SAL_CALL DicEntry::getReplacementText(  )
1088 {
1089     MutexGuard  aGuard( GetLinguMutex() );
1090     return aReplacement;
1091 }
1092
1093
1094 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */