The Tor Browser: extensions/spellcheck/hunspell/src/mozHunspell.cpp@6474c204b198 (annotated)

extensions/spellcheck/hunspell/src/mozHunspell.cpp@6474c204b198 (annotated)

extensions/spellcheck/hunspell/src/mozHunspell.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /******* BEGIN LICENSE BLOCK *******
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  * for the specific language governing rights and limitations under the
  * License.
  *
  * The Initial Developers of the Original Code are Kevin Hendricks (MySpell)
  * and László Németh (Hunspell). Portions created by the Initial Developers
  * are Copyright (C) 2002-2005 the Initial Developers. All Rights Reserved.
  *
  * Contributor(s): Kevin Hendricks (kevin.hendricks@sympatico.ca)
  *                 David Einstein (deinst@world.std.com)
  *                 Michiel van Leeuwen (mvl@exedo.nl)
  *                 Caolan McNamara (cmc@openoffice.org)
  *                 László Németh (nemethl@gyorsposta.hu)
  *                 Davide Prina
  *                 Giuseppe Modugno
  *                 Gianluca Turconi
  *                 Simon Brouwer
  *                 Noll Janos
  *                 Biro Arpad
  *                 Goldman Eleonora
  *                 Sarlos Tamas
  *                 Bencsath Boldizsar
  *                 Halacsy Peter
  *                 Dvornik Laszlo
  *                 Gefferth Andras
  *                 Nagy Viktor
  *                 Varga Daniel
  *                 Chris Halls
  *                 Rene Engelhard
  *                 Bram Moolenaar
  *                 Dafydd Jones
  *                 Harri Pitkanen
  *                 Andras Timar
  *                 Tor Lillqvist
  *                 Jesper Kristensen (mail@jesperkristensen.dk)
  *
  * Alternatively, the contents of this file may be used under the terms of
  * either the GNU General Public License Version 2 or later (the "GPL"), or
  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  * in which case the provisions of the GPL or the LGPL are applicable instead
  * of those above. If you wish to allow use of your version of this file only
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  ******* END LICENSE BLOCK *******/
 #include "mozHunspell.h"
 #include "nsReadableUtils.h"
 #include "nsXPIDLString.h"
 #include "nsIObserverService.h"
 #include "nsISimpleEnumerator.h"
 #include "nsIDirectoryEnumerator.h"
 #include "nsIFile.h"
 #include "nsDirectoryServiceUtils.h"
 #include "nsDirectoryServiceDefs.h"
 #include "mozISpellI18NManager.h"
 #include "nsICharsetConverterManager.h"
 #include "nsUnicharUtilCIID.h"
 #include "nsUnicharUtils.h"
 #include "nsCRT.h"
 #include "mozInlineSpellChecker.h"
 #include "mozilla/Services.h"
 #include <stdlib.h>
 #include "nsIPrefService.h"
 #include "nsIPrefBranch.h"
 static NS_DEFINE_CID(kUnicharUtilCID, NS_UNICHARUTIL_CID);
 NS_IMPL_CYCLE_COLLECTING_ADDREF(mozHunspell)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(mozHunspell)
 NS_INTERFACE_MAP_BEGIN(mozHunspell)
   NS_INTERFACE_MAP_ENTRY(mozISpellCheckingEngine)
   NS_INTERFACE_MAP_ENTRY(nsIObserver)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
   NS_INTERFACE_MAP_ENTRY(nsIMemoryReporter)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozISpellCheckingEngine)
   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(mozHunspell)
 NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTION(mozHunspell,
                          mPersonalDictionary,
                          mEncoder,
                          mDecoder)
 template<> mozilla::Atomic<size_t> mozilla::CountingAllocatorBase<HunspellAllocator>::sAmount(0);
 mozHunspell::mozHunspell()
   : mHunspell(nullptr)
 {
 #ifdef DEBUG
   // There must be only one instance of this class: it reports memory based on
   // a single static count in HunspellAllocator.
   static bool hasRun = false;
   MOZ_ASSERT(!hasRun);
   hasRun = true;
 #endif
 }
 nsresult
 mozHunspell::Init()
 {
   LoadDictionaryList();
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (obs) {
     obs->AddObserver(this, "profile-do-change", true);
     obs->AddObserver(this, "profile-after-change", true);
   }
   mozilla::RegisterWeakMemoryReporter(this);
   return NS_OK;
 }
 mozHunspell::~mozHunspell()
 {
   mozilla::UnregisterWeakMemoryReporter(this);
   mPersonalDictionary = nullptr;
   delete mHunspell;
 }
 /* attribute wstring dictionary; */
 NS_IMETHODIMP mozHunspell::GetDictionary(char16_t **aDictionary)
 {
   NS_ENSURE_ARG_POINTER(aDictionary);
   *aDictionary = ToNewUnicode(mDictionary);
   return *aDictionary ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 /* set the Dictionary.
  * This also Loads the dictionary and initializes the converter using the dictionaries converter
  */
 NS_IMETHODIMP mozHunspell::SetDictionary(const char16_t *aDictionary)
 {
   NS_ENSURE_ARG_POINTER(aDictionary);
   if (nsDependentString(aDictionary).IsEmpty()) {
     delete mHunspell;
     mHunspell = nullptr;
     mDictionary.AssignLiteral("");
     mAffixFileName.AssignLiteral("");
     mLanguage.AssignLiteral("");
     mDecoder = nullptr;
     mEncoder = nullptr;
     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
     if (obs) {
       obs->NotifyObservers(nullptr,
                            SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION,
                            nullptr);
     }
     return NS_OK;
   }
   nsIFile* affFile = mDictionaries.GetWeak(nsDependentString(aDictionary));
   if (!affFile)
     return NS_ERROR_FILE_NOT_FOUND;
   nsAutoCString dictFileName, affFileName;
   // XXX This isn't really good. nsIFile->NativePath isn't safe for all
   // character sets on Windows.
   // A better way would be to QI to nsIFile, and get a filehandle
   // from there. Only problem is that hunspell wants a path
   nsresult rv = affFile->GetNativePath(affFileName);
   NS_ENSURE_SUCCESS(rv, rv);
   if (mAffixFileName.Equals(affFileName.get()))
     return NS_OK;
   dictFileName = affFileName;
   int32_t dotPos = dictFileName.RFindChar('.');
   if (dotPos == -1)
     return NS_ERROR_FAILURE;
   dictFileName.SetLength(dotPos);
   dictFileName.AppendLiteral(".dic");
   // SetDictionary can be called multiple times, so we might have a
   // valid mHunspell instance which needs cleaned up.
   delete mHunspell;
   mDictionary = aDictionary;
   mAffixFileName = affFileName;
   mHunspell = new Hunspell(affFileName.get(),
                          dictFileName.get());
   if (!mHunspell)
     return NS_ERROR_OUT_OF_MEMORY;
   nsCOMPtr<nsICharsetConverterManager> ccm =
     do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = ccm->GetUnicodeDecoder(mHunspell->get_dic_encoding(),
                               getter_AddRefs(mDecoder));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = ccm->GetUnicodeEncoder(mHunspell->get_dic_encoding(),
                               getter_AddRefs(mEncoder));
   NS_ENSURE_SUCCESS(rv, rv);
   if (mEncoder)
     mEncoder->SetOutputErrorBehavior(mEncoder->kOnError_Signal, nullptr, '?');
   int32_t pos = mDictionary.FindChar('-');
   if (pos == -1)
     pos = mDictionary.FindChar('_');
   if (pos == -1)
     mLanguage.Assign(mDictionary);
   else
     mLanguage = Substring(mDictionary, 0, pos);
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (obs) {
     obs->NotifyObservers(nullptr,
                          SPELLCHECK_DICTIONARY_UPDATE_NOTIFICATION,
                          nullptr);
   }
   return NS_OK;
 }
 /* readonly attribute wstring language; */
 NS_IMETHODIMP mozHunspell::GetLanguage(char16_t **aLanguage)
 {
   NS_ENSURE_ARG_POINTER(aLanguage);
   if (mDictionary.IsEmpty())
     return NS_ERROR_NOT_INITIALIZED;
   *aLanguage = ToNewUnicode(mLanguage);
   return *aLanguage ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 }
 /* readonly attribute boolean providesPersonalDictionary; */
 NS_IMETHODIMP mozHunspell::GetProvidesPersonalDictionary(bool *aProvidesPersonalDictionary)
 {
   NS_ENSURE_ARG_POINTER(aProvidesPersonalDictionary);
   *aProvidesPersonalDictionary = false;
   return NS_OK;
 }
 /* readonly attribute boolean providesWordUtils; */
 NS_IMETHODIMP mozHunspell::GetProvidesWordUtils(bool *aProvidesWordUtils)
 {
   NS_ENSURE_ARG_POINTER(aProvidesWordUtils);
   *aProvidesWordUtils = false;
   return NS_OK;
 }
 /* readonly attribute wstring name; */
 NS_IMETHODIMP mozHunspell::GetName(char16_t * *aName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 /* readonly attribute wstring copyright; */
 NS_IMETHODIMP mozHunspell::GetCopyright(char16_t * *aCopyright)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 /* attribute mozIPersonalDictionary personalDictionary; */
 NS_IMETHODIMP mozHunspell::GetPersonalDictionary(mozIPersonalDictionary * *aPersonalDictionary)
 {
   *aPersonalDictionary = mPersonalDictionary;
   NS_IF_ADDREF(*aPersonalDictionary);
   return NS_OK;
 }
 NS_IMETHODIMP mozHunspell::SetPersonalDictionary(mozIPersonalDictionary * aPersonalDictionary)
 {
   mPersonalDictionary = aPersonalDictionary;
   return NS_OK;
 }
 struct AppendNewStruct
 {
   char16_t **dics;
   uint32_t count;
   bool failed;
 };
 static PLDHashOperator
 AppendNewString(const nsAString& aString, nsIFile* aFile, void* aClosure)
 {
   AppendNewStruct *ans = (AppendNewStruct*) aClosure;
   ans->dics[ans->count] = ToNewUnicode(aString);
   if (!ans->dics[ans->count]) {
     ans->failed = true;
     return PL_DHASH_STOP;
   }
   ++ans->count;
   return PL_DHASH_NEXT;
 }
 /* void GetDictionaryList ([array, size_is (count)] out wstring dictionaries, out uint32_t count); */
 NS_IMETHODIMP mozHunspell::GetDictionaryList(char16_t ***aDictionaries,
                                             uint32_t *aCount)
 {
   if (!aDictionaries || !aCount)
     return NS_ERROR_NULL_POINTER;
   AppendNewStruct ans = {
     (char16_t**) NS_Alloc(sizeof(char16_t*) * mDictionaries.Count()),
 ,
     false
   };
   // This pointer is used during enumeration
   mDictionaries.EnumerateRead(AppendNewString, &ans);
   if (ans.failed) {
     while (ans.count) {
       --ans.count;
       NS_Free(ans.dics[ans.count]);
     }
     NS_Free(ans.dics);
     return NS_ERROR_OUT_OF_MEMORY;
   }
   *aDictionaries = ans.dics;
   *aCount = ans.count;
   return NS_OK;
 }
 void
 mozHunspell::LoadDictionaryList()
 {
   mDictionaries.Clear();
   nsresult rv;
   nsCOMPtr<nsIProperties> dirSvc =
     do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
   if (!dirSvc)
     return;
   // find built in dictionaries, or dictionaries specified in
   // spellchecker.dictionary_path in prefs
   nsCOMPtr<nsIFile> dictDir;
   // check preferences first
   nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
   if (prefs) {
     nsCString extDictPath;
     rv = prefs->GetCharPref("spellchecker.dictionary_path", getter_Copies(extDictPath));
     if (NS_SUCCEEDED(rv)) {
       // set the spellchecker.dictionary_path
       rv = NS_NewNativeLocalFile(extDictPath, true, getter_AddRefs(dictDir));
     }
   }
   if (!dictDir) {
     // spellcheck.dictionary_path not found, set internal path
     rv = dirSvc->Get(DICTIONARY_SEARCH_DIRECTORY,
                      NS_GET_IID(nsIFile), getter_AddRefs(dictDir));
   }
   if (dictDir) {
     LoadDictionariesFromDir(dictDir);
   }
   else {
     // try to load gredir/dictionaries
     nsCOMPtr<nsIFile> greDir;
     rv = dirSvc->Get(NS_GRE_DIR,
                      NS_GET_IID(nsIFile), getter_AddRefs(greDir));
     if (NS_SUCCEEDED(rv)) {
       greDir->AppendNative(NS_LITERAL_CSTRING("dictionaries"));
       LoadDictionariesFromDir(greDir);
     }
     // try to load appdir/dictionaries only if different than gredir
     nsCOMPtr<nsIFile> appDir;
     rv = dirSvc->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
                      NS_GET_IID(nsIFile), getter_AddRefs(appDir));
     bool equals;
     if (NS_SUCCEEDED(rv) && NS_SUCCEEDED(appDir->Equals(greDir, &equals)) && !equals) {
       appDir->AppendNative(NS_LITERAL_CSTRING("dictionaries"));
       LoadDictionariesFromDir(appDir);
     }
   }
   // find dictionaries from extensions requiring restart
   nsCOMPtr<nsISimpleEnumerator> dictDirs;
   rv = dirSvc->Get(DICTIONARY_SEARCH_DIRECTORY_LIST,
                    NS_GET_IID(nsISimpleEnumerator), getter_AddRefs(dictDirs));
   if (NS_FAILED(rv))
     return;
   bool hasMore;
   while (NS_SUCCEEDED(dictDirs->HasMoreElements(&hasMore)) && hasMore) {
     nsCOMPtr<nsISupports> elem;
     dictDirs->GetNext(getter_AddRefs(elem));
     dictDir = do_QueryInterface(elem);
     if (dictDir)
       LoadDictionariesFromDir(dictDir);
   }
   // find dictionaries from restartless extensions
   for (int32_t i = 0; i < mDynamicDirectories.Count(); i++) {
     LoadDictionariesFromDir(mDynamicDirectories[i]);
   }
   // Now we have finished updating the list of dictionaries, update the current
   // dictionary and any editors which may use it.
   mozInlineSpellChecker::UpdateCanEnableInlineSpellChecking();
   // Check if the current dictionary is still available.
   // If not, try to replace it with another dictionary of the same language.
   if (!mDictionary.IsEmpty()) {
     rv = SetDictionary(mDictionary.get());
     if (NS_SUCCEEDED(rv))
       return;
   }
   // If the current dictionary has gone, and we don't have a good replacement,
   // set no current dictionary.
   if (!mDictionary.IsEmpty()) {
     SetDictionary(EmptyString().get());
   }
 }
 NS_IMETHODIMP
 mozHunspell::LoadDictionariesFromDir(nsIFile* aDir)
 {
   nsresult rv;
   bool check = false;
   rv = aDir->Exists(&check);
   if (NS_FAILED(rv) || !check)
     return NS_ERROR_UNEXPECTED;
   rv = aDir->IsDirectory(&check);
   if (NS_FAILED(rv) || !check)
     return NS_ERROR_UNEXPECTED;
   nsCOMPtr<nsISimpleEnumerator> e;
   rv = aDir->GetDirectoryEntries(getter_AddRefs(e));
   if (NS_FAILED(rv))
     return NS_ERROR_UNEXPECTED;
   nsCOMPtr<nsIDirectoryEnumerator> files(do_QueryInterface(e));
   if (!files)
     return NS_ERROR_UNEXPECTED;
   nsCOMPtr<nsIFile> file;
   while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(file))) && file) {
     nsAutoString leafName;
     file->GetLeafName(leafName);
     if (!StringEndsWith(leafName, NS_LITERAL_STRING(".dic")))
       continue;
     nsAutoString dict(leafName);
     dict.SetLength(dict.Length() - 4); // magic length of ".dic"
     // check for the presence of the .aff file
     leafName = dict;
     leafName.AppendLiteral(".aff");
     file->SetLeafName(leafName);
     rv = file->Exists(&check);
     if (NS_FAILED(rv) || !check)
       continue;
 #ifdef DEBUG_bsmedberg
     printf("Adding dictionary: %s\n", NS_ConvertUTF16toUTF8(dict).get());
 #endif
     mDictionaries.Put(dict, file);
   }
   return NS_OK;
 }
 nsresult mozHunspell::ConvertCharset(const char16_t* aStr, char ** aDst)
 {
   NS_ENSURE_ARG_POINTER(aDst);
   NS_ENSURE_TRUE(mEncoder, NS_ERROR_NULL_POINTER);
   int32_t outLength;
   int32_t inLength = NS_strlen(aStr);
   nsresult rv = mEncoder->GetMaxLength(aStr, inLength, &outLength);
   NS_ENSURE_SUCCESS(rv, rv);
   *aDst = (char *) nsMemory::Alloc(sizeof(char) * (outLength+1));
   NS_ENSURE_TRUE(*aDst, NS_ERROR_OUT_OF_MEMORY);
   rv = mEncoder->Convert(aStr, &inLength, *aDst, &outLength);
   if (NS_SUCCEEDED(rv))
     (*aDst)[outLength] = '\0';
   return rv;
 }
 /* boolean Check (in wstring word); */
 NS_IMETHODIMP mozHunspell::Check(const char16_t *aWord, bool *aResult)
 {
   NS_ENSURE_ARG_POINTER(aWord);
   NS_ENSURE_ARG_POINTER(aResult);
   NS_ENSURE_TRUE(mHunspell, NS_ERROR_FAILURE);
   nsXPIDLCString charsetWord;
   nsresult rv = ConvertCharset(aWord, getter_Copies(charsetWord));
   NS_ENSURE_SUCCESS(rv, rv);
   *aResult = !!mHunspell->spell(charsetWord);
   if (!*aResult && mPersonalDictionary)
     rv = mPersonalDictionary->Check(aWord, mLanguage.get(), aResult);
   return rv;
 }
 /* void Suggest (in wstring word, [array, size_is (count)] out wstring suggestions, out uint32_t count); */
 NS_IMETHODIMP mozHunspell::Suggest(const char16_t *aWord, char16_t ***aSuggestions, uint32_t *aSuggestionCount)
 {
   NS_ENSURE_ARG_POINTER(aSuggestions);
   NS_ENSURE_ARG_POINTER(aSuggestionCount);
   NS_ENSURE_TRUE(mHunspell, NS_ERROR_FAILURE);
   nsresult rv;
   *aSuggestionCount = 0;
   nsXPIDLCString charsetWord;
   rv = ConvertCharset(aWord, getter_Copies(charsetWord));
   NS_ENSURE_SUCCESS(rv, rv);
   char ** wlst;
   *aSuggestionCount = mHunspell->suggest(&wlst, charsetWord);
   if (*aSuggestionCount) {
     *aSuggestions  = (char16_t **)nsMemory::Alloc(*aSuggestionCount * sizeof(char16_t *));
     if (*aSuggestions) {
       uint32_t index = 0;
       for (index = 0; index < *aSuggestionCount && NS_SUCCEEDED(rv); ++index) {
         // Convert the suggestion to utf16
         int32_t inLength = strlen(wlst[index]);
         int32_t outLength;
         rv = mDecoder->GetMaxLength(wlst[index], inLength, &outLength);
         if (NS_SUCCEEDED(rv))
         {
           (*aSuggestions)[index] = (char16_t *) nsMemory::Alloc(sizeof(char16_t) * (outLength+1));
           if ((*aSuggestions)[index])
           {
             rv = mDecoder->Convert(wlst[index], &inLength, (*aSuggestions)[index], &outLength);
             if (NS_SUCCEEDED(rv))
               (*aSuggestions)[index][outLength] = 0;
           }
           else
             rv = NS_ERROR_OUT_OF_MEMORY;
         }
       }
       if (NS_FAILED(rv))
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(index, *aSuggestions); // free the char16_t strings up to the point at which the error occurred
     }
     else // if (*aSuggestions)
       rv = NS_ERROR_OUT_OF_MEMORY;
   }
   NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(*aSuggestionCount, wlst);
   return rv;
 }
 NS_IMETHODIMP
 mozHunspell::Observe(nsISupports* aSubj, const char *aTopic,
                     const char16_t *aData)
 {
   NS_ASSERTION(!strcmp(aTopic, "profile-do-change")
                || !strcmp(aTopic, "profile-after-change"),
                "Unexpected observer topic");
   LoadDictionaryList();
   return NS_OK;
 }
 /* void addDirectory(in nsIFile dir); */
 NS_IMETHODIMP mozHunspell::AddDirectory(nsIFile *aDir)
 {
   mDynamicDirectories.AppendObject(aDir);
   LoadDictionaryList();
   return NS_OK;
 }
 /* void removeDirectory(in nsIFile dir); */
 NS_IMETHODIMP mozHunspell::RemoveDirectory(nsIFile *aDir)
 {
   mDynamicDirectories.RemoveObject(aDir);
   LoadDictionaryList();
   return NS_OK;
 }

The Tor Browser / annotate

extensions/spellcheck/hunspell/src/mozHunspell.cpp@6474c204b198 (annotated)

extensions/spellcheck/hunspell/src/mozHunspell.cpp