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

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

extensions/spellcheck/src/mozEnglishWordUtils.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.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "mozEnglishWordUtils.h"
 #include "nsReadableUtils.h"
 #include "nsIServiceManager.h"
 #include "nsUnicharUtils.h"
 #include "nsUnicharUtilCIID.h"
 #include "nsUnicodeProperties.h"
 #include "nsCRT.h"
 #include "mozilla/Likely.h"
 NS_IMPL_CYCLE_COLLECTING_ADDREF(mozEnglishWordUtils)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(mozEnglishWordUtils)
 NS_INTERFACE_MAP_BEGIN(mozEnglishWordUtils)
   NS_INTERFACE_MAP_ENTRY(mozISpellI18NUtil)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozISpellI18NUtil)
   NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(mozEnglishWordUtils)
 NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTION(mozEnglishWordUtils,
                          mURLDetector)
 mozEnglishWordUtils::mozEnglishWordUtils()
 {
   mLanguage.AssignLiteral("en");
   nsresult rv;
   mURLDetector = do_CreateInstance(MOZ_TXTTOHTMLCONV_CONTRACTID, &rv);
 }
 mozEnglishWordUtils::~mozEnglishWordUtils()
 {
 }
 /* attribute wstring language; */
 NS_IMETHODIMP mozEnglishWordUtils::GetLanguage(char16_t * *aLanguage)
 {
   nsresult rv = NS_OK;
   NS_ENSURE_ARG_POINTER(aLanguage);
   *aLanguage = ToNewUnicode(mLanguage);
   if(!aLanguage) rv = NS_ERROR_OUT_OF_MEMORY;
   return rv;
  }
 /* void GetRootForm (in wstring aWord, in uint32_t type, [array, size_is (count)] out wstring words, out uint32_t count); */
 // return the possible root forms of aWord.
 NS_IMETHODIMP mozEnglishWordUtils::GetRootForm(const char16_t *aWord, uint32_t type, char16_t ***words, uint32_t *count)
 {
   nsAutoString word(aWord);
   char16_t **tmpPtr;
   int32_t length = word.Length();
   *count = 0;
   mozEnglishWordUtils::myspCapitalization ct = captype(word);
   switch (ct)
     {
     case HuhCap:
     case NoCap:
       tmpPtr = (char16_t **)nsMemory::Alloc(sizeof(char16_t *));
       if (!tmpPtr)
         return NS_ERROR_OUT_OF_MEMORY;
       tmpPtr[0] = ToNewUnicode(word);
       if (!tmpPtr[0]) {
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(0, tmpPtr);
         return NS_ERROR_OUT_OF_MEMORY;
       }
       *words = tmpPtr;
       *count = 1;
       break;
     case AllCap:
       tmpPtr = (char16_t **)nsMemory::Alloc(sizeof(char16_t *) * 3);
       if (!tmpPtr)
         return NS_ERROR_OUT_OF_MEMORY;
       tmpPtr[0] = ToNewUnicode(word);
       if (!tmpPtr[0]) {
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(0, tmpPtr);
         return NS_ERROR_OUT_OF_MEMORY;
       }
       ToLowerCase(tmpPtr[0], tmpPtr[0], length);
       tmpPtr[1] = ToNewUnicode(word);
       if (!tmpPtr[1]) {
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(1, tmpPtr);
         return NS_ERROR_OUT_OF_MEMORY;
       }
       ToLowerCase(tmpPtr[1], tmpPtr[1], length);
       ToUpperCase(tmpPtr[1], tmpPtr[1], 1);
       tmpPtr[2] = ToNewUnicode(word);
       if (!tmpPtr[2]) {
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(2, tmpPtr);
         return NS_ERROR_OUT_OF_MEMORY;
       }
       *words = tmpPtr;
       *count = 3;
       break;
     case InitCap:
       tmpPtr = (char16_t **)nsMemory::Alloc(sizeof(char16_t *) * 2);
       if (!tmpPtr)
         return NS_ERROR_OUT_OF_MEMORY;
       tmpPtr[0] = ToNewUnicode(word);
       if (!tmpPtr[0]) {
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(0, tmpPtr);
         return NS_ERROR_OUT_OF_MEMORY;
       }
       ToLowerCase(tmpPtr[0], tmpPtr[0], length);
       tmpPtr[1] = ToNewUnicode(word);
       if (!tmpPtr[1]) {
         NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(1, tmpPtr);
         return NS_ERROR_OUT_OF_MEMORY;
       }
       *words = tmpPtr;
       *count = 2;
       break;
     default:
       return NS_ERROR_FAILURE; // should never get here;
     }
   return NS_OK;
 }
 // This needs vast improvement
 bool mozEnglishWordUtils::ucIsAlpha(char16_t aChar)
 {
   // XXX we have to fix callers to handle the full Unicode range
   return nsIUGenCategory::kLetter == mozilla::unicode::GetGenCategory(aChar);
 }
 /* void FindNextWord (in wstring word, in uint32_t length, in uint32_t offset, out uint32_t begin, out uint32_t end); */
 NS_IMETHODIMP mozEnglishWordUtils::FindNextWord(const char16_t *word, uint32_t length, uint32_t offset, int32_t *begin, int32_t *end)
 {
   const char16_t *p = word + offset;
   const char16_t *endbuf = word + length;
   const char16_t *startWord=p;
   if(p<endbuf){
     // XXX These loops should be modified to handle non-BMP characters.
     // if previous character is a word character, need to advance out of the word
     if (offset > 0 && ucIsAlpha(*(p-1))) {
       while (p < endbuf && ucIsAlpha(*p))
         p++;
     }
     while((p < endbuf) && (!ucIsAlpha(*p)))
       {
         p++;
       }
     startWord=p;
     while((p < endbuf) && ((ucIsAlpha(*p))||(*p=='\'')))
       {
         p++;
       }
     // we could be trying to break down a url, we don't want to break a url into parts,
     // instead we want to find out if it really is a url and if so, skip it, advancing startWord
     // to a point after the url.
     // before we spend more time looking to see if the word is a url, look for a url identifer
     // and make sure that identifer isn't the last character in the word fragment.
     if ( (*p == ':' || *p == '@' || *p == '.') &&  p < endbuf - 1) {
         // ok, we have a possible url...do more research to find out if we really have one
         // and determine the length of the url so we can skip over it.
         if (mURLDetector)
         {
           int32_t startPos = -1;
           int32_t endPos = -1;
           mURLDetector->FindURLInPlaintext(startWord, endbuf - startWord, p - startWord, &startPos, &endPos);
           // ok, if we got a url, adjust the array bounds, skip the current url text and find the next word again
           if (startPos != -1 && endPos != -1) {
             startWord = p + endPos + 1; // skip over the url
             p = startWord; // reset p
             // now recursively call FindNextWord to search for the next word now that we have skipped the url
             return FindNextWord(word, length, startWord - word, begin, end);
           }
         }
     }
     while((p > startWord)&&(*(p-1) == '\'')){  // trim trailing apostrophes
       p--;
     }
   }
   else{
     startWord = endbuf;
   }
   if(startWord == endbuf){
     *begin = -1;
     *end = -1;
   }
   else{
     *begin = startWord-word;
     *end = p-word;
   }
   return NS_OK;
 }
 mozEnglishWordUtils::myspCapitalization
 mozEnglishWordUtils::captype(const nsString &word)
 {
   char16_t* lword=ToNewUnicode(word);
   ToUpperCase(lword,lword,word.Length());
   if(word.Equals(lword)){
     nsMemory::Free(lword);
     return AllCap;
   }
   ToLowerCase(lword,lword,word.Length());
   if(word.Equals(lword)){
     nsMemory::Free(lword);
     return NoCap;
   }
   int32_t length=word.Length();
   if(Substring(word,1,length-1).Equals(lword+1)){
     nsMemory::Free(lword);
     return InitCap;
   }
   nsMemory::Free(lword);
   return HuhCap;
 }
 // Convert the list of words in iwords to the same capitalization aWord and
 // return them in owords.
 NS_IMETHODIMP mozEnglishWordUtils::FromRootForm(const char16_t *aWord, const char16_t **iwords, uint32_t icount, char16_t ***owords, uint32_t *ocount)
 {
   nsAutoString word(aWord);
   nsresult rv = NS_OK;
   int32_t length;
   char16_t **tmpPtr  = (char16_t **)nsMemory::Alloc(sizeof(char16_t *)*icount);
   if (!tmpPtr)
     return NS_ERROR_OUT_OF_MEMORY;
   mozEnglishWordUtils::myspCapitalization ct = captype(word);
   for(uint32_t i = 0; i < icount; ++i) {
     length = NS_strlen(iwords[i]);
     tmpPtr[i] = (char16_t *) nsMemory::Alloc(sizeof(char16_t) * (length + 1));
     if (MOZ_UNLIKELY(!tmpPtr[i])) {
       NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, tmpPtr);
       return NS_ERROR_OUT_OF_MEMORY;
     }
     memcpy(tmpPtr[i], iwords[i], (length + 1) * sizeof(char16_t));
     nsAutoString capTest(tmpPtr[i]);
     mozEnglishWordUtils::myspCapitalization newCt=captype(capTest);
     if(newCt == NoCap){
       switch(ct)
         {
         case HuhCap:
         case NoCap:
           break;
         case AllCap:
           ToUpperCase(tmpPtr[i],tmpPtr[i],length);
           rv = NS_OK;
           break;
         case InitCap:
           ToUpperCase(tmpPtr[i],tmpPtr[i],1);
           rv = NS_OK;
           break;
         default:
           rv = NS_ERROR_FAILURE; // should never get here;
           break;
         }
     }
   }
   if (NS_SUCCEEDED(rv)){
     *owords = tmpPtr;
     *ocount = icount;
   }
   return rv;
 }

The Tor Browser / annotate

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

extensions/spellcheck/src/mozEnglishWordUtils.cpp