void SpellingChecker_addNewWord (SpellingChecker me, const char32 *word) {
try {
autostring32 generic = Melder_calloc (char32, 3 * str32len (word) + 1);
Longchar_genericize32 (word, generic.peek());
my userDictionary -> addString_copy (generic.transfer());
} catch (MelderError) {
Melder_throw (me, U": word \"", word, U"\" not added.");
}
}
void SpellingChecker_addNewWord (SpellingChecker me, const char32 *word) {
try {
if (! my userDictionary)
my userDictionary = SortedSetOfString_create ();
autostring32 generic = Melder_calloc (char32, 3 * str32len (word) + 1);
Longchar_genericize32 (word, generic.peek());
SortedSetOfString_addString (my userDictionary, generic.transfer());
} catch (MelderError) {
Melder_throw (me, U": word \"", word, U"\" not added.");
}
}
void Strings_genericize (Strings me) {
autostring32 buffer = Melder_calloc (char32, Strings_maximumLength (me) * 3 + 1);
for (long i = 1; i <= my numberOfStrings; i ++) {
const char32 *p = (const char32 *) my strings [i];
while (*p) {
if (*p > 126) { // backslashes are not converted, i.e. genericize^2 == genericize
Longchar_genericize32 (my strings [i], buffer.peek());
autostring32 newString = Melder_dup (buffer.peek());
/*
* Replace string only if copying was OK.
*/
Melder_free (my strings [i]);
my strings [i] = newString.transfer();
break;
}
p ++;
}
}
}
bool WordList_hasWord (WordList me, const char32 *word) {
long p, d;
int cf;
if (str32len (word) > 3333) return false;
Longchar_genericize32 (word, buffer);
if (! my length) my length = str32len (my string);
p = my length / 2, d = p / 2;
while (d > 20) {
p = gotoStart (me, p);
cf = compare (buffer, my string + p);
if (cf == 0) return true;
if (cf < 0) p -= d; else p += d;
d /= 2;
}
p = gotoStart (me, p);
cf = compare (buffer, my string + p);
if (cf == 0) return true;
if (cf > 0) {
for (;;) {
p = gotoNext (me, p);
if (p >= my length) return false;
cf = compare (buffer, my string + p);
if (cf == 0) return true;
if (cf < 0) return false;
}
} else {
for (;;) {
p = gotoPrevious (me, p);
if (p < 0) return false;
cf = compare (buffer, my string + p);
if (cf == 0) return true;
if (cf > 0) return false;
}
}
return false; // should not occur
}
bool SpellingChecker_isWordAllowed (SpellingChecker me, const char32 *word) {
int wordLength = str32len (word);
if (my allowAllWordsContaining && my allowAllWordsContaining [0]) {
char32 *p = & my allowAllWordsContaining [0];
while (*p) {
/*
* Find next token in list of allowed string parts.
*/
char32 token [100], *q = & token [0];
/*
* Skip spaces in list.
*/
while (*p == U' ') p ++;
/*
* Collect one token string from list.
*/
while (*p != U'\0' && *p != U' ') {
*q ++ = *p ++;
}
*q = U'\0'; // trailing null character
/*
* Allow word if it contains this token.
*/
if (str32str (word, token)) return true;
}
}
if (my allowAllNames) {
/*
* Allow word if it starts with a capital.
*/
if (startsWithCapital (word)) {
return true;
}
if (my namePrefixes && my namePrefixes [0]) {
char32 *p = & my namePrefixes [0];
while (*p) {
char32 token [100], *q = & token [0];
while (*p == U' ') p ++;
while (*p != U'\0' && *p != U' ') *q ++ = *p ++;
*q = U'\0'; // trailing null character
/*
* Allow word if starts with this prefix
* and this prefix is followed by a capital.
*/
if (str32str (word, token) == word && startsWithCapital (word + str32len (token))) {
return true;
}
}
}
} else if (my allowAllAbbreviations && startsWithCapital (word)) {
const char32 *p = & word [0];
for (;;) {
if (*p == '\0') return true;
if (iswlower ((int) *p)) break;
p ++;
}
}
if (my allowAllWordsStartingWith && my allowAllWordsStartingWith [0]) {
char32 *p = & my allowAllWordsStartingWith [0];
while (*p) {
char32 token [100], *q = & token [0];
int tokenLength;
while (*p == U' ') p ++;
while (*p != U'\0' && *p != U' ') *q ++ = *p ++;
*q = U'\0'; // trailing null character
tokenLength = str32len (token);
if (wordLength >= tokenLength && str32nequ (token, word, tokenLength)) {
return true;
}
}
}
if (my allowAllWordsEndingIn && my allowAllWordsEndingIn [0]) {
char32 *p = & my allowAllWordsEndingIn [0];
while (*p) {
char32 token [100], *q = & token [0];
int tokenLength;
while (*p == U' ') p ++;
while (*p != U'\0' && *p != U' ') *q ++ = *p ++;
*q = U'\0'; // trailing null character
tokenLength = str32len (token);
if (wordLength >= tokenLength && str32nequ (token, word + wordLength - tokenLength, tokenLength)) {
return true;
}
}
}
if (WordList_hasWord (my wordList, word))
return true;
if (my userDictionary != NULL) {
if (str32len (word) > 3333) return false; // superfluous, because WordList_hasWord already checked; but safe
static char32 buffer [3*3333+1];
Longchar_genericize32 (word, buffer);
if (SortedSetOfString_lookUp (my userDictionary, buffer) != 0)
return true;
}
return false;
}
const char32 *SimpleString_genericize_c (SimpleString me) {
autoSimpleString thee = Data_copy (me);
my string = (char32 *) Melder_realloc (my string, (3 * str32len (my string) + 1) * (int64) sizeof (char32));
Longchar_genericize32 (thy string, my string);
return my string;
}
