summaryrefslogtreecommitdiffstats
path: root/extensions/spellcheck/src/mozEnglishWordUtils.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /extensions/spellcheck/src/mozEnglishWordUtils.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'extensions/spellcheck/src/mozEnglishWordUtils.cpp')
-rw-r--r--extensions/spellcheck/src/mozEnglishWordUtils.cpp284
1 files changed, 284 insertions, 0 deletions
diff --git a/extensions/spellcheck/src/mozEnglishWordUtils.cpp b/extensions/spellcheck/src/mozEnglishWordUtils.cpp
new file mode 100644
index 000000000..5033b247b
--- /dev/null
+++ b/extensions/spellcheck/src/mozEnglishWordUtils.cpp
@@ -0,0 +1,284 @@
+/* -*- 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()
+{
+}
+
+NS_IMETHODIMP mozEnglishWordUtils::GetLanguage(char16_t * *aLanguage)
+{
+ NS_ENSURE_ARG_POINTER(aLanguage);
+
+ *aLanguage = ToNewUnicode(mLanguage);
+ if (!*aLanguage) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ return NS_OK;
+}
+
+// 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 **)moz_xmalloc(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 **)moz_xmalloc(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 **)moz_xmalloc(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);
+}
+
+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)){
+ free(lword);
+ return AllCap;
+ }
+
+ ToLowerCase(lword,lword,word.Length());
+ if(word.Equals(lword)){
+ free(lword);
+ return NoCap;
+ }
+ int32_t length=word.Length();
+ if(Substring(word,1,length-1).Equals(lword+1)){
+ free(lword);
+ return InitCap;
+ }
+ 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 **)moz_xmalloc(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 *) moz_xmalloc(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;
+}
+