{

char* word;

uint64 flags;

{

memset(lengthLists,0,sizeof(MEANING) * 100);

WORDP D = dictionaryBase;

while (++D < dictionaryFree)

{

if (D->properties & PART_OF_SPEECH || D->systemFlags & PATTERN_WORD)

{

if (!IsAlphaUTF8(*D->word) || WORDLENGTH(D) >= 50 || strchr(D->word, ' ') || strchr(D->word, '_')) continue;

WORDINFO wordData;

ComputeWordData(D->word, &wordData);

D->spellNode = lengthLists[wordData.charlen];

lengthLists[wordData.charlen] = MakeMeaning(D);

}

}

{

size_t len = strlen(utfstring);

return (!strncmp(word, utfstring, len));

{

size_t len1 = strlen(word);

// Do not split acronyms (all uppercase) unless word before or after is lowercase

size_t j;

for (j = 0; j < len1; ++j)

{

if (!IsUpperCase(word[j])) break;

}

if (j == len1) // looks like acronym but is any neighbor non caps

{

if (wordStarts[i - 1] && IsUpperCase(wordStarts[i - 1][0])) j = 0;

if (wordStarts[i + 1] && IsUpperCase(wordStarts[i + 1][0])) j = 0;

}

if (j == len1) return 0;

WORDP D2;

bool good;

int breakAt = 0;

if (IsDigit(*word))

{

while (IsDigit(word[++breakAt]) || word[breakAt] == '.' || word[breakAt] == ','){;} // find end of number

if (word[breakAt]) // found end of number

{

D2 = FindWord(word+breakAt,0,PRIMARY_CASE_ALLOWED);

if (D2)

{

good = (D2->properties & (PART_OF_SPEECH|FOREIGN_WORD)) != 0 || (D2->systemFlags & HAS_SUBSTITUTE) != 0;

if (good && (D2->systemFlags & AGE_LEARNED))// must be common words we find

{

char number[MAX_WORD_SIZE];

strncpy(number,word,breakAt);

number[breakAt] = 0;

StoreWord(number,ADJECTIVE|NOUN|ADJECTIVE_NUMBER|NOUN_NUMBER);

return breakAt; // split here

}

}

}

}

// dont split acronyms

// try all combinations of breaking the word into two known words

bool isEnglish = (!stricmp(current_language, "english") ? true : false);

bool isFrench = (!stricmp(current_language, "french") ? true : false);

breakAt = 0;

size_t len = strlen(word);

for (unsigned int k = 1; k < len-1; ++k)

{

if (isEnglish && k == 1 && *word != 'a' && *word != 'A' && *word != 'i' && *word != 'I') continue; // only a and i are allowed single-letter words

else if (isFrench && k == 1 && *word != 'y' && *word != 'a' && *word != 'A' && !SameUTF(word,"à") && !SameUTF(word, "À") && !SameUTF(word, "ô") && !SameUTF(word,"Ô")) continue; // in french only y, a and ô are allowed single-letter words

WORDP D1 = FindWord(word,k,PRIMARY_CASE_ALLOWED);

if (!D1) continue;

good = (D1->properties & (PART_OF_SPEECH|FOREIGN_WORD)) != 0 || (D1->systemFlags & HAS_SUBSTITUTE) != 0;

if (good)

{

if (D1->systemFlags & AGE_LEARNED || GetMeaningCount(D1) > 1);

else good = false;

}

if (!good ) continue; // must be normal common words we find

D2 = FindWord(word+k,len-k,PRIMARY_CASE_ALLOWED);

if (!D2) continue;

good = (D2->properties & (PART_OF_SPEECH|FOREIGN_WORD)) != 0 || (D2->systemFlags & HAS_SUBSTITUTE) != 0;

if (good)

{

if (D2->systemFlags & AGE_LEARNED || GetMeaningCount(D2) > 1);

else good = false;

}

if (!good ) continue; // must be normal common words we find

if (!breakAt) breakAt = k; // found a split

else // found multiple places to split... dont know what to do

{

breakAt = -1;

break;

}

}

return breakAt;

{

if (!D) return false;

if (D->properties & TAG_TEST) return true;

if (D->systemFlags & (PATTERN_WORD || HAS_SUBSTITUTE)) return true;

FACT* F = GetSubjectNondeadHead(D);

// concept members are useful. If from api call, it would be the only fact on a new word

if (F && (F->verb == Mmember || F->verb == Mexclude || F->verb == Mremapfact)) return true;

return false;

{

WORDP D = NULL;

int len = strlen(word) - 2; // minimum joined piece

while (--len >= 0) // minimum size leftover 2 (dont do tiny words)

{

D = FindWord(word + len, 0, UPPERCASE_LOOKUP); // 2nd word if noun will be upper

if (D && !(D->properties & (NOUN | VERB | ADJECTIVE | ADVERB))) D = NULL;

if (!D) D = FindWord(word + len, 0, LOWERCASE_LOOKUP); // 2nd word other

if (D && !(D->properties & (NOUN | VERB | ADJECTIVE | ADVERB))) D = NULL;

if (D)

{

while (--len >= 0) // keep going

{

WORDP F = FindWord(word + len, 0, UPPERCASE_LOOKUP); // 2nd word if noun will be upper

if (!F) F = FindWord(word + len, 0, LOWERCASE_LOOKUP); // 2nd word other

if (F && !(F->properties & (NOUN | VERB | ADJECTIVE | ADVERB))) F = NULL;

if (len == 0 && length) break; // dont swallow entire known word

if (F) D = F; // found longer, upgrade to it

}

}

}

return D;

{

if (start < 1 || end > wordCount || start > wordCount) return false; // not legal - negative start will appear big

char word[MAX_WORD_SIZE * 5 + 10]; // composite up to 5 words safely

char* ptr = word;

for (unsigned int i = start; i <= end; ++i)

{

strcpy(ptr, wordStarts[i]);

ptr += strlen(wordStarts[i]);

*ptr++ = '_';

}

*--ptr = 0;

return FindWord(word) ? true : false;

{

// check sequences of up to 5 in each position

for (unsigned int n = 1; n <= 4; ++n) // in 1st position ?xxxx

{

unsigned int i = posn + n;

if (ValidComposite(posn, i)) return true;

}

for (unsigned int n = 2; n <= 4; ++n) // in 2nd position x?xxx

{

unsigned int i = posn + n - 1;

if (ValidComposite(posn-1, i)) return true;

}

// in 3rd position xx?xx

if (ValidComposite(posn - 2, posn) || ValidComposite(posn - 2, posn + 1) || ValidComposite(posn - 2, posn + 2)) return true;

// in 4th position xxx?x

if (ValidComposite(posn - 3, posn) || ValidComposite(posn - 3, posn + 1)) return true;

// in 5th position xxxx?

if (ValidComposite(posn - 4, posn)) return true;

return false;

{

if (!stricmp(current_language, "ideographic") || !stricmp(current_language, "japanese") || !stricmp(current_language, "chinese")) return false; // no spell check on them

char retry[256];

memset(retry, 0, sizeof(retry));

char* tokens[6];

fixedSpell = false;

bool isEnglish = (!stricmp(current_language, "english") ? true : false);

bool isGerman = (!stricmp(current_language, "german") ? true : false);

bool isSpanish = (!stricmp(current_language, "spanish") ? true : false);

bool isFilipino = (!stricmp(current_language, "filipino") ? true : false);

unsigned int startWord = FindOOBEnd(1);

unsigned int i;

int badspelllimit = 0;

int badspellsize = 0;

float badspellratio = 1.0;

char* baddata = GetUserVariable("$cs_badspellLimit", false); // 10-20 (50%)

if (*baddata)

{

badspelllimit = atoi(baddata);

baddata = strchr(baddata, '-');

if (baddata)

{

badspellsize = atoi(baddata + 1);

badspellratio = (float) badspelllimit / badspellsize;

}

}

bool delayedspell = false;

int spellbad = 0;

int safetylimit = 400;

// verifyrun safety

if (!stricmp(wordStarts[1], "VERIFY") && (*wordStarts[2] == '^' || *wordStarts[2] == '$' || *wordStarts[2] == '%')) return false;

for (i = startWord; i <= wordCount; ++i)

{

if (retry[i-1]) // prior was a problem needing full spellcheck

{

if (++spellbad >= badspelllimit && badspelllimit) // crossed threshhold of number of spellchecks

{

float ratio = (float)spellbad / (i + 1 - startWord); // we never hit last word

if (ratio >= badspellratio)

{

if ((trace & TRACE_BITS) == TRACE_SPELLING) Log(USERLOG,"BadSpell abort NL\r\n");

char junk[100];

sprintf(junk, "%d-%d", spellbad, (i + 1 - startWord));

SetUserVariable("$$cs_badspell", junk);

break;

}

}

}

if (--safetylimit <= 0) break; // in case of infinite loop

char* word = wordStarts[i];

int size = strlen(word);

if (size > (MAX_WORD_SIZE - 100)) continue;

if (size == 4 && !stricmp(word,"json") ) continue; // may not be in dictionary yet

if (IsValidJSONName(word)) continue;

if (!stricmp(serverlogauthcode,word)) continue;

if (!stricmp("bwinfo", word)) continue;

// spanish conjugated word?

if (isSpanish)

{

WORDP entry, canonical = NULL;

uint64 sysflags = 0;

uint64 properties = ComputeSpanish(i, word, entry, canonical, sysflags);

if (!properties) properties = KnownSpanishUnaccented(word, entry,sysflags); // see if accenting is wrong

if (properties) // we figured it out as a conjugation of a verb, noun, or adjective

{

if (entry && strcmp(word, entry->word)) // changed case?

{

tokens[1] = entry->word;

fixedSpell = ReplaceWords("spanish word case change", i, 1, 1, tokens);

}

continue;

}

}

// filipino conjugated word?

if (isFilipino)

{

WORDP entry, canonical = NULL;

uint64 sysflags = 0;

uint64 properties = ComputeFilipino(i, word, entry, canonical, sysflags);

if (properties) // we figured it out as a conjugation of a verb, noun, or adjective

{

if (entry && strcmp(word, entry->word)) // changed ?

{

tokens[1] = entry->word;

fixedSpell = ReplaceWords("filipino word change", i, 1, 1, tokens);

}

continue;

}

}

char bigword[3 * MAX_WORD_SIZE]; // allows join of 2 words

if (spellTrace)

{

strcpy(spellCheckWord, word);

echo = true;

}

// change any \ to /

char newword[MAX_WORD_SIZE];

bool altered = false;

strcpy(newword, word);

char* at = newword;

while ((at = strchr(at, '\\')))

{

if (at[1] == 'n') // newline

{

*at = ' ';

at[1] = ' ';

}

else *at = '/';

altered = true;

}

if (altered) word = wordStarts[i] = StoreWord(newword, AS_IS)->word;

// do we know the word meaningfully as is?

WORDP D = FindWord(word, 0, PRIMARY_CASE_ALLOWED,true); // must match case perfectly if can (iPhone vs IPhone)

if (!D) D = FindWord(word, 0, PRIMARY_CASE_ALLOWED); // take any casing

if ( D && (!IS_NEW_WORD(D) || D->systemFlags & PATTERN_WORD))

{

bool good = false;

if (D->properties & TAG_TEST || *D->word == '~' || D->systemFlags & PATTERN_WORD) good = true; // we know this word clearly or its a concept set ref emotion

else if (D->internalBits & HAS_SUBSTITUTE) good = true;

else if (D <= dictionaryPreBuild[LAYER_0]) good = true; // in dictionary - if a substitute would have happend by now

else if (!isEnglish) good = true; // foreign word we know

else if (IsConceptMember(D)) good = true;

if (good)

{

if (strcmp(D->word, word) && !(D->properties & NOUN_HUMAN)) // different capitalization and not just a human name

{

tokens[1] = D->word;

fixedSpell = ReplaceWords("' alternate capitalization", i, 1, 1, tokens);

}

continue;

}

}

// handle lower case forms of upper case nouns

if (isGerman && !D)

{

WORDP E = FindWord(word, 0, SECONDARY_CASE_ALLOWED);

if (E && E->internalBits & UPPERCASE_HASH && E->properties & NOUN_SINGULAR) // we had lower case, we find upper case

{

tokens[1] = E->word;

fixedSpell = ReplaceWords("' German lowercased noun", i, 1, 1, tokens);

continue;

}

}

// he gave upper case, try easy lower case

WORDP LD = FindWord(word, 0, LOWERCASE_LOOKUP);

if (LD && !IS_NEW_WORD(LD) && IsUpperCase(*wordStarts[i]))

{

bool good = false;

if (LD->properties & TAG_TEST || *LD->word == '~' || LD->systemFlags & PATTERN_WORD) good = true; // we know this word clearly or its a concept set ref emotion

else if (LD <= dictionaryPreBuild[LAYER_0]) good = true; // in dictionary - if a substitute would have happend by now

else if (!isEnglish) good = true; // foreign word we know

else if (IsConceptMember(LD)) good = true;

if (good)

{

tokens[1] = LD->word;

fixedSpell = ReplaceWords("' lowercase", i, 1, 1, tokens);

continue;

}

}

if (IsDate(word)) continue; // allow 1970/10/5 or similar

if (IsEmojiShortname(word)) continue; // allow emojis

// o for 0 in number

char xtra[MAX_WORD_SIZE];

strcpy(xtra, word);

char* p = xtra;

if (IsSign(*p)) ++p; // skip sign indicator, -$1,234.56

char* prefixEnd = IsSymbolCurrency((char*)p); // is it at start

if (prefixEnd) p = prefixEnd;

int period = 0;

bool notnum = false;

if (IsDigit(*p))

{

while (p && *++p)

{

if (*p == '.')

{

if (++period > 1) p = NULL;

}

else if (*p == 'o' || *p == 'O') *p = '0';

else if (!IsDigit(*p))

{

p = NULL;

notnum = true;

}

}

if (period <= 1 && !notnum && stricmp(xtra, word))

{

WORDP X = StoreWord(xtra);

tokens[1] = X->word;

fixedSpell = ReplaceWords("o for 0 number", i, 1, 1, tokens);

continue;

}

}

// dont spell check numbers

size_t l = strlen(word);

char* end = word + l;

if (IsFloat(word, end, numberStyle)) continue;

if (IsFractionNumber(word)) continue;

if (IsDigitWord(word, numberStyle, false, true)) continue;

if (IsUrl(word, word + l)) continue;

// appended &quot?

if (*word != '&' && !stricmp(word + l - 5, "&quot"))

{

word[l - 5] = 0;

WORDP X = StoreWord(word);

tokens[1] = X->word;

tokens[2] = "\"";

fixedSpell = ReplaceWords("split &quot", i, 1, 2, tokens);

--i; // retry spellcheck

continue;

}

if (*word == '\'')

{

WORDP X = ApostropheBreak(word);

if (X)

{

tokens[1] = X->word;

fixedSpell = ReplaceWords("' replace", i, 1, 1, tokens);

continue;

}

}

// degrees

if ((unsigned char)*word == 0xc2 && (unsigned char)word[1] == 0xb0 && !word[3]) continue; // leave degreeC,F,K, etc alone

if (isEnglish && *word == '\'' && !word[1] && i != startWord && IsDigit(*wordStarts[i - 1])) // fails if not digit bug

{

tokens[1] = (char*)"foot";

fixedSpell = ReplaceWords("' as feet", i, 1, 1, tokens);

continue;

}

if (isEnglish && *word == '"' && !word[1] && i != startWord && IsDigit(*wordStarts[i - 1])) // fails if not digit bug

{

tokens[1] = (char*)"inch";

fixedSpell = ReplaceWords("' as feet", i, 1, 1, tokens);

continue;

}

if (!word[1] || *word == '"') continue; // single char or quoted thingy

// dont spell check email or other things with @ or . in them

if (strchr(word, '@') || strchr(word, '&') || strchr(word, '$')) continue;

// dont spell check hashtags

if (word[0] == '#' && !IsDigit(word[1])) {

bool validHash = true;

for (int j = 1; j < size; ++j) {

if (!IsAlphaUTF8OrDigit(word[j]) && word[j] != '_') {

validHash = false;

break;

}

}

if (validHash) continue;

}

// dont spell check names of json objects or arrays

if (IsValidJSONName(word)) continue;

// dont spell check web addresses

if (!strnicmp(word, "http", 4) || !strnicmp(word, "www", 3)) continue;

// dont spell check abbreviations with dots, e.g. p.m.

char* dot = strchr(word, '.');

if (dot && FindWord(word, 0)) continue;

// joined number words like 100dollars

at = word - 1;

while (IsDigit(*++at) || *at == '.' || *at == ',');

if (IsDigit(*word) && strlen(at) > 3 && ProbableKnownWord(at))

{

char first[MAX_WORD_SIZE];

strncpy(first, word, (at - word));

first[at - word] = 0;

if (IsDigitWord(first, numberStyle, true))

{

tokens[1] = first;

tokens[2] = at;

fixedSpell = ReplaceWords("joined number word", i, 1, 2, tokens);

continue;

}

}

// embedded double quotes

char* quo = strchr(word, '"');

if (quo)

{

// mistaken " for 1 in don"t?

if (quo[1] == 't' && !quo[2])

{

*quo = '\'';

tokens[1] = word;

fixedSpell = ReplaceWords("q for dq", i, 1, 1, tokens);

continue;

}

// number-inch-object 76"element tv

if (IsAlphaUTF8(quo[1]) && IsDigit(*word))

{

char* at = word;

while (IsDigit(*++at) || *at == '.'); // scan number

if (at == quo)

{

*quo = 0;

tokens[1] = word;

tokens[2] = "inch";

tokens[3] = quo+1;

fixedSpell = ReplaceWords("joined word number", i, 1, 3, tokens);

continue;

}

}

}

// allow data1 and its friends for regression tests

// joined number words like dollars100, but allow single digits at end - assume model numbers are not normal words with number after

at = end;

while (at >= word && (IsDigit(*--at) || *at == '.' || *at == ','));

if (IsDigit(*++at) && at[1] && (at - word) > 3 && IsDigitWord(at, numberStyle, true))

{

char first[MAX_WORD_SIZE];

strncpy(first, word, (at - word));

first[at - word] = 0;

if (ProbableKnownWord(first))

{

tokens[1] = first;

tokens[2] = at;

fixedSpell = ReplaceWords("joined word number", i, 1, 2, tokens);

continue;

}

}

// dont spellcheck model numbers

if (IsModelNumber(word))

{

WORDP X = FindWord(word, 0, UPPERCASE_LOOKUP);

if (IsConceptMember(X) && !strcmp(word, X->word))

{

tokens[1] = X->word;

fixedSpell = ReplaceWords("KnownUpperModelNumber", i, 1, 1, tokens);

}

continue;

}

// don't spellcheck initials

if (IsMadeOfInitials(word, end) == ABBREVIATION) continue;

if (ValidSequence(i)) continue; // leave alone if part of phrase

if (i != wordCount) // merge 2 adj words w hyphen if can, even though one but not both are legal words

{

// for German be cognizant that nouns are uppercase and hence more useful, 3 Tage is preferred to 3-Tage

uint64 primaryCaseX = (isGerman && IsUpperCase(*word)) ? UPPERCASE_LOOKUP : LOWERCASE_LOOKUP;

uint64 secondaryCaseX = (primaryCaseX == LOWERCASE_LOOKUP) ? UPPERCASE_LOOKUP : LOWERCASE_LOOKUP;

uint64 primaryCaseY = (isGerman && IsUpperCase(*wordStarts[i + 1])) ? UPPERCASE_LOOKUP : LOWERCASE_LOOKUP;;

uint64 secondaryCaseY = (primaryCaseY == LOWERCASE_LOOKUP) ? UPPERCASE_LOOKUP : LOWERCASE_LOOKUP;;

size_t len = strlen(word);

WORDP X = FindWord(word,len);

WORDP Y = FindWord(wordStarts[i + 1]);

bool useful1 = UsefulKnownWord(X);

bool useful2 = UsefulKnownWord(Y);

if (!(X && Y && useful1 && useful2)) // has-been is a word we dont want merge,but model numbers we do.

{

// first check merge 2 using _

strcpy(bigword, word);

bigword[len] = '_';

strcpy(bigword + len + 1, wordStarts[i + 1]);

WORDP XX = FindWord(bigword);

if (XX && UsefulKnownWord(XX))

{

++i;

continue; // its fine joined, will detect as sequence later

}

// try merge with -

bigword[len] = '-';

XX = FindWord(bigword);

if (XX && UsefulKnownWord(XX))

{

tokens[1] = XX->word;

fixedSpell = ReplaceWords("merge to hyphenword", i, 2, 1, tokens);

continue;

}

}

}

// split conjoined sentetence Missouri.Fix or Missouri..Fix

// but dont split float values like 0.5%

if (dot && dot != word && dot[1] && !IsDigit(dot[1]))

{

*dot = 0;

// don't spell correct if this looks like a filename

char* rest = dot + 1;

if (!IsFileExtension(rest)) {

WORDP X = FindWord(word, 0);

while (rest[0] == '.') ++rest; // swallow all excess dots

WORDP Y = FindWord(rest, 0);

if (X && Y) // we recognize the words

{

char oper[10];

tokens[1] = word;

tokens[2] = oper;

*oper = '.';

oper[1] = 0;

tokens[3] = rest;

fixedSpell = ReplaceWords("dotsentence", i, 1, 3, tokens);

*dot = '.'; // restore the dot so the original is still in derivationSentence

continue;

}

}

*dot = '.'; // restore the dot

}

// dont spell check things with . in them

if (dot) continue;

char* number;

if (GetCurrency((unsigned char*)word, number)) continue; // currency

if (isEnglish && !stricmp(word, (char*)"am") && i != startWord &&

(IsDigit(*wordStarts[i - 1]) || IsNumber(wordStarts[i - 1], numberStyle) == REAL_NUMBER)) // fails if not digit bug

{

tokens[1] = (char*)"a.m.";

fixedSpell = ReplaceWords("am as time", i, 1, 1, tokens);

continue;

}

// words with excess repeated characters >2 => 2

char excess[MAX_WORD_SIZE];

if (!IsDigit(word[1]) && word[1] != '.' && word[1] != ',')

{

size_t len = size;

strcpy(excess, word);

bool change = false;

for (int j = 0; j < size; ++j)

{

if (excess[j] == excess[j + 1])

{

memmove(excess + j + 1, excess + j + 2, strlen(excess + j + 1));

if (FindWord(excess))

{

tokens[1] = excess;

fixedSpell = ReplaceWords("2 repeat letters", i, 1, 1, tokens);

break;

}

else strcpy(excess, word);

}

}

if (change) continue;

}

// words with excess repeated characters 2=>1 unless root noun or verb

if (IS_NEW_WORD(FindWord(word)) && !IsDigit(word[1]) && word[1] != '.' && word[1] != ',')

{

if (!stricmp(current_language, "english"))

{

char* noun = GetSingularNoun(word, false, true);

if (noun && strcmp(word, noun)) continue;

char* verb = GetInfinitive(word, true);

if (verb && strcmp(word, verb)) continue;

}

strcpy(excess, word);

bool change = false;

for (int j = 0; j < size; ++j)

{

if (excess[j] == excess[j + 1])

{

memmove(excess + j + 1, excess + j + 2, strlen(excess + j + 1));

if (FindWord(excess))

{

tokens[1] = excess;

fixedSpell = ReplaceWords("2 repeat letters", i, 1, 1, tokens);

break;

}

else strcpy(excess, word);

}

}

if (change) continue;

}

// split arithmetic 1+2

if (IsDigit(*word) && IsDigit(word[size - 1]))

{

char first[MAX_WORD_SIZE];

strncpy(first, word, size);

first[size] = 0;

at = first;

while (IsDigit(*++at) || *at == '.' || *at == ',') { ; }

char* op = at;

if (*at == '+' || *at == '-' || *at == '*' || *at == '/')

{

while (IsDigit(*++at) || *at == '.' || *at == ',') { ; }

if (!*at && (size != 9 || *op != '-')) // 445+455 but not zip code

{

char oper[10];

tokens[2] = oper;

*oper = *op;

oper[1] = 0;

*op = 0;

tokens[1] = first;

tokens[3] = op + 1;

fixedSpell = ReplaceWords("smooshed 1+2", i, 1, 3, tokens);

continue;

}

}

}

// split off trailing -

if (size > 1 && word[size - 1] == '-')

{

WORDP X = FindWord(word, size - 1);

if (X)

{

tokens[1] = X->word;

tokens[2] = "-";

fixedSpell = ReplaceWords("trailing hyphen split", i, 1, 2, tokens);

continue;

}

}

// merge with next token?

if (i != wordCount && *wordStarts[i + 1] != '"')

{

// direct merge as a single word

strcpy(bigword, word);

strcat(bigword, wordStarts[i + 1]);

D = FindWord(bigword, 0, (tokenControl & ONLY_LOWERCASE) ? PRIMARY_CASE_ALLOWED : STANDARD_LOOKUP);

if (D && D->properties & PART_OF_SPEECH && !(D->properties & AUX_VERB)) {} // merge these two, except "going to" or wordnet composites of normal words

else // merge with underscore? shia tsu

{

strcpy(bigword, word);

strcat(bigword, "_");

strcat(bigword, wordStarts[i + 1]);

D = FindWord(bigword, 0, (tokenControl & ONLY_LOWERCASE) ? PRIMARY_CASE_ALLOWED : STANDARD_LOOKUP);

if (D && D->properties & PART_OF_SPEECH && !(D->properties & AUX_VERB)) // allow these two, except "going to" or wordnet composites of normal words

{