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