/*!
* Upcase variant that works on normal strings. Note that it is a lot
* slower than the normal upcase. The input must be in canonical form.
*
* \param s
*/
void ISpellChecker::chupcase(char *s)
{
ichar_t *is;
is = strtosichar(s, 1);
upcase(is);
ichartostr(s, is, strlen(s) + 1, 1);
}
/*!
* \param word Word to be saved
* \param pattern Capitalization pattern
* \param prestrip No. chars stripped from front
* \param preadd No. chars added to front of root
* \param sufstrip No. chars stripped from back
* \param sufadd No. chars added to back of root
* \param firstdent First dent for root
* \param pfxent Pfx-flag entry for word
* \param sufent Sfx-flag entry for word
* \param savearea Room to save words
* \param nsaved Number saved so far (updated)
*/
void
ISpellChecker::save_root_cap (ichar_t *word, ichar_t *pattern,
int prestrip, int preadd, int sufstrip, int sufadd,
struct dent *firstdent, struct flagent *pfxent, struct flagent *sufent,
ichar_t savearea[MAX_CAPS][INPUTWORDLEN + MAXAFFIXLEN],
int * nsaved)
{
#ifndef NO_CAPITALIZATION_SUPPORT
register struct dent * dent;
#endif /* NO_CAPITALIZATION_SUPPORT */
int firstisupper;
ichar_t newword[INPUTWORDLEN + 4 * MAXAFFIXLEN + 4];
#ifndef NO_CAPITALIZATION_SUPPORT
register ichar_t * p;
int len;
int i;
int limit;
#endif /* NO_CAPITALIZATION_SUPPORT */
if (*nsaved >= MAX_CAPS)
return;
icharcpy (newword, word);
firstisupper = myupper (pattern[0]);
#ifdef NO_CAPITALIZATION_SUPPORT
/*
** Apply the old, simple-minded capitalization rules.
*/
if (firstisupper)
{
if (myupper (pattern[1]))
upcase (newword);
else
{
lowcase (newword);
newword[0] = mytoupper (newword[0]);
}
}
else
lowcase (newword);
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
return;
#else /* NO_CAPITALIZATION_SUPPORT */
#define flagsareok(dent) \
((pfxent == NULL \
|| TSTMASKBIT (dent->mask, pfxent->flagbit)) \
&& (sufent == NULL \
|| TSTMASKBIT (dent->mask, sufent->flagbit)))
dent = firstdent;
if ((dent->flagfield & (CAPTYPEMASK | MOREVARIANTS)) == ALLCAPS)
{
upcase (newword); /* Uppercase required */
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
return;
}
for (p = pattern; *p; p++)
{
if (mylower (*p))
break;
}
if (*p == 0)
{
upcase (newword); /* Pattern was all caps */
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
return;
}
for (p = pattern + 1; *p; p++)
{
if (myupper (*p))
break;
}
if (*p == 0)
{
/*
** The pattern was all-lower or capitalized. If that's
** legal, insert only that version.
*/
if (firstisupper)
{
if (captype (dent->flagfield) == CAPITALIZED
|| captype (dent->flagfield) == ANYCASE)
{
lowcase (newword);
newword[0] = mytoupper (newword[0]);
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
return;
}
}
else
{
if (captype (dent->flagfield) == ANYCASE)
{
lowcase (newword);
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
return;
}
}
while (dent->flagfield & MOREVARIANTS)
{
dent = dent->next;
if (captype (dent->flagfield) == FOLLOWCASE
|| !flagsareok (dent))
continue;
if (firstisupper)
{
if (captype (dent->flagfield) == CAPITALIZED)
{
lowcase (newword);
newword[0] = mytoupper (newword[0]);
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
return;
}
}
else
{
if (captype (dent->flagfield) == ANYCASE)
{
lowcase (newword);
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
return;
}
}
}
}
/*
** Either the sample had complex capitalization, or the simple
** capitalizations (all-lower or capitalized) are illegal.
** Insert all legal capitalizations, including those that are
** all-lower or capitalized. If the prototype is capitalized,
** capitalized all-lower samples. Watch out for affixes.
*/
dent = firstdent;
p = strtosichar (dent->word, 1);
len = icharlen (p);
if (dent->flagfield & MOREVARIANTS)
dent = dent->next; /* Skip place-holder entry */
for ( ; ; )
{
if (flagsareok (dent))
{
if (captype (dent->flagfield) != FOLLOWCASE)
{
lowcase (newword);
if (firstisupper || captype (dent->flagfield) == CAPITALIZED)
newword[0] = mytoupper (newword[0]);
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
if (*nsaved >= MAX_CAPS)
return;
}
else
{
/* Followcase is the tough one. */
p = strtosichar (dent->word, 1);
memmove (
reinterpret_cast<char *>(newword + preadd),
reinterpret_cast<char *>(p + prestrip),
(len - prestrip - sufstrip) * sizeof (ichar_t));
if (myupper (p[prestrip]))
{
for (i = 0; i < preadd; i++)
newword[i] = mytoupper (newword[i]);
}
else
{
for (i = 0; i < preadd; i++)
newword[i] = mytolower (newword[i]);
}
limit = len + preadd + sufadd - prestrip - sufstrip;
i = len + preadd - prestrip - sufstrip;
p += len - sufstrip - 1;
if (myupper (*p))
{
for (p = newword + i; i < limit; i++, p++)
*p = mytoupper (*p);
}
else
{
for (p = newword + i; i < limit; i++, p++)
*p = mytolower (*p);
}
icharcpy (savearea[*nsaved], newword);
(*nsaved)++;
if (*nsaved >= MAX_CAPS)
return;
}
}
if ((dent->flagfield & MOREVARIANTS) == 0)
break; /* End of the line */
dent = dent->next;
}
return;
#endif /* NO_CAPITALIZATION_SUPPORT */
}