extensions/spellcheck/hunspell/src/mozHunspell.cpp

   1 /******* BEGIN LICENSE BLOCK *******
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Initial Developers of the Original Code are Kevin Hendricks (MySpell)
  15  * and László Németh (Hunspell). Portions created by the Initial Developers
  16  * are Copyright (C) 2002-2005 the Initial Developers. All Rights Reserved.
  17  *
  18  * Contributor(s): Kevin Hendricks (kevin.hendricks@sympatico.ca)
  19  *                 David Einstein (deinst@world.std.com)
  20  *                 Michiel van Leeuwen (mvl@exedo.nl)
  21  *                 Caolan McNamara (cmc@openoffice.org)
  22  *                 László Németh (nemethl@gyorsposta.hu)
  23  *                 Davide Prina
  24  *                 Giuseppe Modugno
  25  *                 Gianluca Turconi
  26  *                 Simon Brouwer
  27  *                 Noll Janos
  28  *                 Biro Arpad
  29  *                 Goldman Eleonora
  30  *                 Sarlos Tamas
  31  *                 Bencsath Boldizsar
  32  *                 Halacsy Peter
  33  *                 Dvornik Laszlo
  34  *                 Gefferth Andras
  35  *                 Nagy Viktor
  36  *                 Varga Daniel
  37  *                 Chris Halls
  38  *                 Rene Engelhard
  39  *                 Bram Moolenaar
  40  *                 Dafydd Jones
  41  *                 Harri Pitkanen
  42  *                 Andras Timar
  43  *                 Tor Lillqvist
  44  *
  45  * Alternatively, the contents of this file may be used under the terms of
  46  * either the GNU General Public License Version 2 or later (the "GPL"), or
  47  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  48  * in which case the provisions of the GPL or the LGPL are applicable instead
  49  * of those above. If you wish to allow use of your version of this file only
  50  * under the terms of either the GPL or the LGPL, and not to allow others to
  51  * use your version of this file under the terms of the MPL, indicate your
  52  * decision by deleting the provisions above and replace them with the notice
  53  * and other provisions required by the GPL or the LGPL. If you do not delete
  54  * the provisions above, a recipient may use your version of this file under
  55  * the terms of any one of the MPL, the GPL or the LGPL.
  56  *
  57  ******* END LICENSE BLOCK *******/
  58
  59 #include "mozHunspell.h"
  60 #include "nsReadableUtils.h"
  61 #include "nsXPIDLString.h"
  62 #include "nsIObserverService.h"
  63 #include "nsISimpleEnumerator.h"
  64 #include "nsIDirectoryEnumerator.h"
  65 #include "nsIFile.h"
  66 #include "nsDirectoryServiceUtils.h"
  67 #include "nsDirectoryServiceDefs.h"
  68 #include "mozISpellI18NManager.h"
  69 #include "nsICharsetConverterManager.h"
  70 #include "nsUnicharUtilCIID.h"
  71 #include "nsUnicharUtils.h"
  72 #include "nsCRT.h"
  73 #include <stdlib.h>
  74
  75 static NS_DEFINE_CID(kCharsetConverterManagerCID, NS_ICHARSETCONVERTERMANAGER_CID);
  76 static NS_DEFINE_CID(kUnicharUtilCID, NS_UNICHARUTIL_CID);
  77
  78 NS_IMPL_ISUPPORTS3(mozHunspell,
  79                    mozISpellCheckingEngine,
  80                    nsIObserver,
  81                    nsISupportsWeakReference)
  82
  83 nsresult
  84 mozHunspell::Init()
  85 {
  86   if (!mDictionaries.Init())
  87     return NS_ERROR_OUT_OF_MEMORY;
  88
  89   LoadDictionaryList();
  90
  91   nsCOMPtr<nsIObserverService> obs =
  92     do_GetService("@mozilla.org/observer-service;1");
  93   if (obs) {
  94     obs->AddObserver(this, "profile-do-change", PR_TRUE);
  95   }
  96
  97   return NS_OK;
  98 }
  99
 100 mozHunspell::~mozHunspell()
 101 {
 102   mPersonalDictionary = nsnull;
 103   delete mHunspell;
 104 }
 105
 106 /* attribute wstring dictionary; */
 107 NS_IMETHODIMP mozHunspell::GetDictionary(PRUnichar **aDictionary)
 108 {
 109   NS_ENSURE_ARG_POINTER(aDictionary);
 110
 111   if (mDictionary.IsEmpty())
 112     return NS_ERROR_NOT_INITIALIZED;
 113
 114   *aDictionary = ToNewUnicode(mDictionary);
 115   return *aDictionary ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 116 }
 117
 118 /* set the Dictionary.
 119  * This also Loads the dictionary and initializes the converter using the dictionaries converter
 120  */
 121 NS_IMETHODIMP mozHunspell::SetDictionary(const PRUnichar *aDictionary)
 122 {
 123   NS_ENSURE_ARG_POINTER(aDictionary);
 124
 125   if (mDictionary.Equals(aDictionary))
 126     return NS_OK;
 127
 128   nsIFile* affFile = mDictionaries.GetWeak(nsDependentString(aDictionary));
 129   if (!affFile)
 130     return NS_ERROR_FILE_NOT_FOUND;
 131
 132   nsCAutoString dictFileName, affFileName;
 133
 134   // XXX This isn't really good. nsIFile->NativePath isn't safe for all
 135   // character sets on Windows.
 136   // A better way would be to QI to nsILocalFile, and get a filehandle
 137   // from there. Only problem is that hunspell wants a path
 138
 139   nsresult rv = affFile->GetNativePath(affFileName);
 140   NS_ENSURE_SUCCESS(rv, rv);
 141
 142   dictFileName = affFileName;
 143   PRInt32 dotPos = dictFileName.RFindChar('.');
 144   if (dotPos == -1)
 145     return NS_ERROR_FAILURE;
 146
 147   dictFileName.SetLength(dotPos);
 148   dictFileName.AppendLiteral(".dic");
 149
 150   // SetDictionary can be called multiple times, so we might have a
 151   // valid mHunspell instance which needs cleaned up.
 152   delete mHunspell;
 153
 154   mDictionary = aDictionary;
 155
 156   mHunspell = new Hunspell(affFileName.get(),
 157                          dictFileName.get());
 158   if (!mHunspell)
 159     return NS_ERROR_OUT_OF_MEMORY;
 160
 161   nsCOMPtr<nsICharsetConverterManager> ccm =
 162     do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
 163   NS_ENSURE_SUCCESS(rv, rv);
 164
 165   rv = ccm->GetUnicodeDecoder(mHunspell->get_dic_encoding(),
 166                               getter_AddRefs(mDecoder));
 167   NS_ENSURE_SUCCESS(rv, rv);
 168
 169   rv = ccm->GetUnicodeEncoder(mHunspell->get_dic_encoding(),
 170                               getter_AddRefs(mEncoder));
 171   NS_ENSURE_SUCCESS(rv, rv);
 172
 173
 174   if (mEncoder)
 175     mEncoder->SetOutputErrorBehavior(mEncoder->kOnError_Signal, nsnull, '?');
 176
 177   PRInt32 pos = mDictionary.FindChar('-');
 178   if (pos == -1)
 179     pos = mDictionary.FindChar('_');
 180
 181   if (pos == -1)
 182     mLanguage.Assign(mDictionary);
 183   else
 184     mLanguage = Substring(mDictionary, 0, pos);
 185
 186   return NS_OK;
 187 }
 188
 189 /* readonly attribute wstring language; */
 190 NS_IMETHODIMP mozHunspell::GetLanguage(PRUnichar **aLanguage)
 191 {
 192   NS_ENSURE_ARG_POINTER(aLanguage);
 193
 194   if (mDictionary.IsEmpty())
 195     return NS_ERROR_NOT_INITIALIZED;
 196
 197   *aLanguage = ToNewUnicode(mLanguage);
 198   return *aLanguage ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 199 }
 200
 201 /* readonly attribute boolean providesPersonalDictionary; */
 202 NS_IMETHODIMP mozHunspell::GetProvidesPersonalDictionary(PRBool *aProvidesPersonalDictionary)
 203 {
 204   NS_ENSURE_ARG_POINTER(aProvidesPersonalDictionary);
 205
 206   *aProvidesPersonalDictionary = PR_FALSE;
 207   return NS_OK;
 208 }
 209
 210 /* readonly attribute boolean providesWordUtils; */
 211 NS_IMETHODIMP mozHunspell::GetProvidesWordUtils(PRBool *aProvidesWordUtils)
 212 {
 213   NS_ENSURE_ARG_POINTER(aProvidesWordUtils);
 214
 215   *aProvidesWordUtils = PR_FALSE;
 216   return NS_OK;
 217 }
 218
 219 /* readonly attribute wstring name; */
 220 NS_IMETHODIMP mozHunspell::GetName(PRUnichar * *aName)
 221 {
 222   return NS_ERROR_NOT_IMPLEMENTED;
 223 }
 224
 225 /* readonly attribute wstring copyright; */
 226 NS_IMETHODIMP mozHunspell::GetCopyright(PRUnichar * *aCopyright)
 227 {
 228   return NS_ERROR_NOT_IMPLEMENTED;
 229 }
 230
 231 /* attribute mozIPersonalDictionary personalDictionary; */
 232 NS_IMETHODIMP mozHunspell::GetPersonalDictionary(mozIPersonalDictionary * *aPersonalDictionary)
 233 {
 234   *aPersonalDictionary = mPersonalDictionary;
 235   NS_IF_ADDREF(*aPersonalDictionary);
 236   return NS_OK;
 237 }
 238
 239 NS_IMETHODIMP mozHunspell::SetPersonalDictionary(mozIPersonalDictionary * aPersonalDictionary)
 240 {
 241   mPersonalDictionary = aPersonalDictionary;
 242   return NS_OK;
 243 }
 244
 245 struct AppendNewStruct
 246 {
 247   PRUnichar **dics;
 248   PRUint32 count;
 249   PRBool failed;
 250 };
 251
 252 static PLDHashOperator
 253 AppendNewString(const nsAString& aString, nsIFile* aFile, void* aClosure)
 254 {
 255   AppendNewStruct *ans = (AppendNewStruct*) aClosure;
 256   ans->dics[ans->count] = ToNewUnicode(aString);
 257   if (!ans->dics[ans->count]) {
 258     ans->failed = PR_TRUE;
 259     return PL_DHASH_STOP;
 260   }
 261
 262   ++ans->count;
 263   return PL_DHASH_NEXT;
 264 }
 265
 266 /* void GetDictionaryList ([array, size_is (count)] out wstring dictionaries, out PRUint32 count); */
 267 NS_IMETHODIMP mozHunspell::GetDictionaryList(PRUnichar ***aDictionaries,
 268                                             PRUint32 *aCount)
 269 {
 270   if (!aDictionaries || !aCount)
 271     return NS_ERROR_NULL_POINTER;
 272
 273   AppendNewStruct ans = {
 274     (PRUnichar**) NS_Alloc(sizeof(PRUnichar*) * mDictionaries.Count()),
 275     0,
 276     PR_FALSE
 277   };
 278
 279   // This pointer is used during enumeration
 280   mDictionaries.EnumerateRead(AppendNewString, &ans);
 281
 282   if (ans.failed) {
 283     while (ans.count) {
 284       --ans.count;
 285       NS_Free(ans.dics[ans.count]);
 286     }
 287     NS_Free(ans.dics);
 288     return NS_ERROR_OUT_OF_MEMORY;
 289   }
 290
 291   *aDictionaries = ans.dics;
 292   *aCount = ans.count;
 293
 294   return NS_OK;
 295 }
 296
 297 void
 298 mozHunspell::LoadDictionaryList()
 299 {
 300   mDictionaries.Clear();
 301
 302   nsresult rv;
 303
 304   nsCOMPtr<nsIProperties> dirSvc =
 305     do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
 306   if (!dirSvc)
 307     return;
 308
 309   nsCOMPtr<nsIFile> dictDir;
 310   rv = dirSvc->Get(DICTIONARY_SEARCH_DIRECTORY,
 311                    NS_GET_IID(nsIFile), getter_AddRefs(dictDir));
 312   if (NS_SUCCEEDED(rv)) {
 313     LoadDictionariesFromDir(dictDir);
 314   }
 315   else {
 316     // try to load gredir/dictionaries
 317     nsCOMPtr<nsIFile> greDir;
 318     rv = dirSvc->Get(NS_GRE_DIR,
 319                      NS_GET_IID(nsIFile), getter_AddRefs(greDir));
 320     if (NS_SUCCEEDED(rv)) {
 321       greDir->AppendNative(NS_LITERAL_CSTRING("dictionaries"));
 322       LoadDictionariesFromDir(greDir);
 323     }
 324
 325     // try to load appdir/dictionaries only if different than gredir
 326     nsCOMPtr<nsIFile> appDir;
 327     rv = dirSvc->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
 328                      NS_GET_IID(nsIFile), getter_AddRefs(appDir));
 329     PRBool equals;
 330     if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(appDir->Equals(greDir, &equals)) && !equals) {
 331       appDir->AppendNative(NS_LITERAL_CSTRING("dictionaries"));
 332       LoadDictionariesFromDir(appDir);
 333     }
 334   }
 335
 336   nsCOMPtr<nsISimpleEnumerator> dictDirs;
 337   rv = dirSvc->Get(DICTIONARY_SEARCH_DIRECTORY_LIST,
 338                    NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(dictDirs));
 339   if (NS_FAILED(rv))
 340     return;
 341
 342   PRBool hasMore;
 343   while (NS_SUCCEEDED(dictDirs->HasMoreElements(&hasMore)) && hasMore) {
 344     nsCOMPtr<nsISupports> elem;
 345     dictDirs->GetNext(getter_AddRefs(elem));
 346
 347     dictDir = do_QueryInterface(elem);
 348     if (dictDir)
 349       LoadDictionariesFromDir(dictDir);
 350   }
 351 }
 352
 353 void
 354 mozHunspell::LoadDictionariesFromDir(nsIFile* aDir)
 355 {
 356   nsresult rv;
 357
 358   PRBool check = PR_FALSE;
 359   rv = aDir->Exists(&check);
 360   if (NS_FAILED(rv) || !check)
 361     return;
 362
 363   rv = aDir->IsDirectory(&check);
 364   if (NS_FAILED(rv) || !check)
 365     return;
 366
 367   nsCOMPtr<nsISimpleEnumerator> e;
 368   rv = aDir->GetDirectoryEntries(getter_AddRefs(e));
 369   if (NS_FAILED(rv))
 370     return;
 371
 372   nsCOMPtr<nsIDirectoryEnumerator> files(do_QueryInterface(e));
 373   if (!files)
 374     return;
 375
 376   nsCOMPtr<nsIFile> file;
 377   while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(file))) && file) {
 378     nsAutoString leafName;
 379     file->GetLeafName(leafName);
 380     if (!StringEndsWith(leafName, NS_LITERAL_STRING(".dic")))
 381       continue;
 382
 383     nsAutoString dict(leafName);
 384     dict.SetLength(dict.Length() - 4); // magic length of ".dic"
 385
 386     // check for the presence of the .aff file
 387     leafName = dict;
 388     leafName.AppendLiteral(".aff");
 389     file->SetLeafName(leafName);
 390     rv = file->Exists(&check);
 391     if (NS_FAILED(rv) || !check)
 392       continue;
 393
 394 #ifdef DEBUG_bsmedberg
 395     printf("Adding dictionary: %s\n", NS_ConvertUTF16toUTF8(dict).get());
 396 #endif
 397
 398     mDictionaries.Put(dict, file);
 399   }
 400 }
 401
 402 nsresult mozHunspell::ConvertCharset(const PRUnichar* aStr, char ** aDst)
 403 {
 404   NS_ENSURE_ARG_POINTER(aDst);
 405   NS_ENSURE_TRUE(mEncoder, NS_ERROR_NULL_POINTER);
 406
 407   PRInt32 outLength;
 408   PRInt32 inLength = nsCRT::strlen(aStr);
 409   nsresult rv = mEncoder->GetMaxLength(aStr, inLength, &outLength);
 410   NS_ENSURE_SUCCESS(rv, rv);
 411
 412   *aDst = (char *) nsMemory::Alloc(sizeof(char) * (outLength+1));
 413   NS_ENSURE_TRUE(*aDst, NS_ERROR_OUT_OF_MEMORY);
 414
 415   rv = mEncoder->Convert(aStr, &inLength, *aDst, &outLength);
 416   if (NS_SUCCEEDED(rv))
 417     (*aDst)[outLength] = '\0';
 418
 419   return rv;
 420 }
 421
 422 /* boolean Check (in wstring word); */
 423 NS_IMETHODIMP mozHunspell::Check(const PRUnichar *aWord, PRBool *aResult)
 424 {
 425   NS_ENSURE_ARG_POINTER(aWord);
 426   NS_ENSURE_ARG_POINTER(aResult);
 427   NS_ENSURE_TRUE(mHunspell, NS_ERROR_FAILURE);
 428
 429   nsXPIDLCString charsetWord;
 430   nsresult rv = ConvertCharset(aWord, getter_Copies(charsetWord));
 431   NS_ENSURE_SUCCESS(rv, rv);
 432
 433   *aResult = !!mHunspell->spell(charsetWord);
 434
 435
 436   if (!*aResult && mPersonalDictionary)
 437     rv = mPersonalDictionary->Check(aWord, mLanguage.get(), aResult);
 438
 439   return rv;
 440 }
 441
 442 /* void Suggest (in wstring word, [array, size_is (count)] out wstring suggestions, out PRUint32 count); */
 443 NS_IMETHODIMP mozHunspell::Suggest(const PRUnichar *aWord, PRUnichar ***aSuggestions, PRUint32 *aSuggestionCount)
 444 {
 445   NS_ENSURE_ARG_POINTER(aSuggestions);
 446   NS_ENSURE_ARG_POINTER(aSuggestionCount);
 447   NS_ENSURE_TRUE(mHunspell, NS_ERROR_FAILURE);
 448
 449   nsresult rv;
 450   *aSuggestionCount = 0;
 451
 452   nsXPIDLCString charsetWord;
 453   rv = ConvertCharset(aWord, getter_Copies(charsetWord));
 454   NS_ENSURE_SUCCESS(rv, rv);
 455
 456   char ** wlst;
 457   *aSuggestionCount = mHunspell->suggest(&wlst, charsetWord);
 458
 459   if (*aSuggestionCount) {
 460     *aSuggestions  = (PRUnichar **)nsMemory::Alloc(*aSuggestionCount * sizeof(PRUnichar *));
 461     if (*aSuggestions) {
 462       PRUint32 index = 0;
 463       for (index = 0; index < *aSuggestionCount && NS_SUCCEEDED(rv); ++index) {
 464         // Convert the suggestion to utf16
 465         PRInt32 inLength = nsCRT::strlen(wlst[index]);
 466         PRInt32 outLength;
 467         rv = mDecoder->GetMaxLength(wlst[index], inLength, &outLength);
 468         if (NS_SUCCEEDED(rv))
 469         {
 470           (*aSuggestions)[index] = (PRUnichar *) nsMemory::Alloc(sizeof(PRUnichar) * (outLength+1));
 471           if ((*aSuggestions)[index])
 472           {
 473             rv = mDecoder->Convert(wlst[index], &inLength, (*aSuggestions)[index], &outLength);
 474             if (NS_SUCCEEDED(rv))
 475               (*aSuggestions)[index][outLength] = 0;
 476           }
 477           else
 478             rv = NS_ERROR_OUT_OF_MEMORY;
 479         }
 480       }
 481
 482       if (NS_FAILED(rv))
 483         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(index, *aSuggestions); // free the PRUnichar strings up to the point at which the error occurred
 484     }
 485     else // if (*aSuggestions)
 486       rv = NS_ERROR_OUT_OF_MEMORY;
 487   }
 488
 489   NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(*aSuggestionCount, wlst);
 490   return rv;
 491 }
 492
 493 NS_IMETHODIMP
 494 mozHunspell::Observe(nsISupports* aSubj, const char *aTopic,
 495                     const PRUnichar *aData)
 496 {
 497   NS_ASSERTION(!strcmp(aTopic, "profile-do-change"),
 498                "Unexpected observer topic");
 499
 500   LoadDictionaryList();
 501
 502   return NS_OK;
 503 }