aboutsummaryrefslogtreecommitdiff
path: root/src/nvim/spell.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/nvim/spell.c')
-rw-r--r--src/nvim/spell.c141
1 files changed, 78 insertions, 63 deletions
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 3b891d998f..d4f49bffb2 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -2309,10 +2309,11 @@ int captype(char_u *word, char_u *end)
for (p = word; !spell_iswordp_nmw(p, curwin); mb_ptr_adv(p))
if (end == NULL ? *p == NUL : p >= end)
return 0; // only non-word characters, illegal word
- if (has_mbyte)
- c = mb_ptr2char_adv(&p);
- else
+ if (has_mbyte) {
+ c = mb_ptr2char_adv((const char_u **)&p);
+ } else {
c = *p++;
+ }
firstcap = allcap = SPELL_ISUPPER(c);
// Need to check all letters to find a word with mixed upper/lower.
@@ -2607,14 +2608,15 @@ static bool spell_iswordp(char_u *p, win_T *wp)
// Returns true if "p" points to a word character.
// Unlike spell_iswordp() this doesn't check for "midword" characters.
-bool spell_iswordp_nmw(char_u *p, win_T *wp)
+bool spell_iswordp_nmw(const char_u *p, win_T *wp)
{
int c;
if (has_mbyte) {
c = mb_ptr2char(p);
- if (c > 255)
+ if (c > 255) {
return spell_mb_isword_class(mb_get_class(p), wp);
+ }
return spelltab.st_isw[c];
}
return spelltab.st_isw[*p];
@@ -2675,7 +2677,7 @@ int spell_casefold(char_u *str, int len, char_u *buf, int buflen)
buf[outi] = NUL;
return FAIL;
}
- c = mb_cptr2char_adv(&p);
+ c = mb_cptr2char_adv((const char_u **)&p);
outi += mb_char2bytes(SPELL_TOFOLD(c), buf + outi);
}
buf[outi] = NUL;
@@ -2937,7 +2939,7 @@ void spell_suggest(int count)
// For redo we use a change-word command.
ResetRedobuff();
- AppendToRedobuff((char_u *)"ciw");
+ AppendToRedobuff("ciw");
AppendToRedobuffLit(p + c,
stp->st_wordlen + sug.su_badlen - stp->st_orglen);
AppendCharToRedobuff(ESC);
@@ -3232,7 +3234,7 @@ static void spell_suggest_expr(suginfo_T *su, char_u *expr)
list_T *list;
listitem_T *li;
int score;
- char_u *p;
+ const char *p;
// The work is split up in a few parts to avoid having to export
// suginfo_T.
@@ -3244,11 +3246,12 @@ static void spell_suggest_expr(suginfo_T *su, char_u *expr)
if (li->li_tv.v_type == VAR_LIST) {
// Get the word and the score from the items.
score = get_spellword(li->li_tv.vval.v_list, &p);
- if (score >= 0 && score <= su->su_maxscore)
- add_suggestion(su, &su->su_ga, p, su->su_badlen,
- score, 0, true, su->su_sallang, false);
+ if (score >= 0 && score <= su->su_maxscore) {
+ add_suggestion(su, &su->su_ga, (const char_u *)p, su->su_badlen,
+ score, 0, true, su->su_sallang, false);
+ }
}
- list_unref(list);
+ tv_list_unref(list);
}
// Remove bogus suggestions, sort and truncate at "maxcount".
@@ -3405,17 +3408,19 @@ void onecap_copy(char_u *word, char_u *wcopy, bool upper)
int l;
p = word;
- if (has_mbyte)
- c = mb_cptr2char_adv(&p);
- else
+ if (has_mbyte) {
+ c = mb_cptr2char_adv((const char_u **)&p);
+ } else {
c = *p++;
- if (upper)
+ }
+ if (upper) {
c = SPELL_TOUPPER(c);
- else
+ } else {
c = SPELL_TOFOLD(c);
- if (has_mbyte)
+ }
+ if (has_mbyte) {
l = mb_char2bytes(c, wcopy);
- else {
+ } else {
l = 1;
wcopy[0] = c;
}
@@ -3432,10 +3437,11 @@ static void allcap_copy(char_u *word, char_u *wcopy)
d = wcopy;
for (s = word; *s != NUL; ) {
- if (has_mbyte)
- c = mb_cptr2char_adv(&s);
- else
+ if (has_mbyte) {
+ c = mb_cptr2char_adv((const char_u **)&s);
+ } else {
c = *s++;
+ }
if (c == 0xdf) {
c = 'S';
@@ -5616,7 +5622,7 @@ static void
add_suggestion (
suginfo_T *su,
garray_T *gap, // either su_ga or su_sga
- char_u *goodword,
+ const char_u *goodword,
int badlenarg, // len of bad word replaced with "goodword"
int score,
int altscore,
@@ -5630,13 +5636,11 @@ add_suggestion (
int badlen; // len of bad word changed
suggest_T *stp;
suggest_T new_sug;
- int i;
- char_u *pgood, *pbad;
// Minimize "badlen" for consistency. Avoids that changing "the the" to
// "thee the" is added next to changing the first "the" the "thee".
- pgood = goodword + STRLEN(goodword);
- pbad = su->su_badptr + badlenarg;
+ const char_u *pgood = goodword + STRLEN(goodword);
+ char_u *pbad = su->su_badptr + badlenarg;
for (;; ) {
goodlen = (int)(pgood - goodword);
badlen = (int)(pbad - su->su_badptr);
@@ -5656,9 +5660,10 @@ add_suggestion (
// the first "the" to itself.
return;
- if (GA_EMPTY(gap))
+ int i;
+ if (GA_EMPTY(gap)) {
i = -1;
- else {
+ } else {
// Check if the word is already there. Also check the length that is
// being replaced "thes," -> "these" is a different suggestion from
// "thes" -> "these".
@@ -5857,27 +5862,31 @@ cleanup_suggestions (
return maxscore;
}
-// Soundfold a string, for soundfold().
-// Result is in allocated memory, NULL for an error.
-char_u *eval_soundfold(char_u *word)
+/// Soundfold a string, for soundfold()
+///
+/// @param[in] word Word to soundfold.
+///
+/// @return [allocated] soundfolded string or NULL in case of error. May return
+/// copy of the input string if soundfolding is not
+/// supported by any of the languages in &spellang.
+char *eval_soundfold(const char *const word)
+ FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
{
- langp_T *lp;
- char_u sound[MAXWLEN];
-
if (curwin->w_p_spell && *curwin->w_s->b_p_spl != NUL) {
// Use the sound-folding of the first language that supports it.
- for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; ++lpi) {
- lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
+ for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; lpi++) {
+ langp_T *const lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
if (!GA_EMPTY(&lp->lp_slang->sl_sal)) {
// soundfold the word
- spell_soundfold(lp->lp_slang, word, false, sound);
- return vim_strsave(sound);
+ char_u sound[MAXWLEN];
+ spell_soundfold(lp->lp_slang, (char_u *)word, false, sound);
+ return xstrdup((const char *)sound);
}
}
}
// No language with sound folding, return word as-is.
- return vim_strsave(word);
+ return xstrdup(word);
}
/// Turn "inword" into its sound-a-like equivalent in "res[MAXWLEN]".
@@ -5934,12 +5943,12 @@ static void spell_soundfold_sofo(slang_T *slang, char_u *inword, char_u *res)
// The sl_sal_first[] table contains the translation for chars up to
// 255, sl_sal the rest.
for (s = inword; *s != NUL; ) {
- c = mb_cptr2char_adv(&s);
- if (enc_utf8 ? utf_class(c) == 0 : ascii_iswhite(c))
+ c = mb_cptr2char_adv((const char_u **)&s);
+ if (enc_utf8 ? utf_class(c) == 0 : ascii_iswhite(c)) {
c = ' ';
- else if (c < 256)
+ } else if (c < 256) {
c = slang->sl_sal_first[c];
- else {
+ } else {
ip = ((int **)slang->sl_sal.ga_data)[c & 0xff];
if (ip == NULL) // empty list, can't match
c = NUL;
@@ -6224,9 +6233,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
int word[MAXWLEN];
int wres[MAXWLEN];
int l;
- char_u *s;
int *ws;
- char_u *t;
int *pf;
int i, j, z;
int reslen;
@@ -6246,9 +6253,9 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
// Remove accents, if wanted. We actually remove all non-word characters.
// But keep white space.
wordlen = 0;
- for (s = inword; *s != NUL; ) {
- t = s;
- c = mb_cptr2char_adv(&s);
+ for (const char_u *s = inword; *s != NUL; ) {
+ const char_u *t = s;
+ c = mb_cptr2char_adv((const char_u **)&s);
if (slang->sl_rem_accents) {
if (enc_utf8 ? utf_class(c) == 0 : ascii_iswhite(c)) {
if (did_white)
@@ -6257,8 +6264,9 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
did_white = true;
} else {
did_white = false;
- if (!spell_iswordp_nmw(t, curwin))
+ if (!spell_iswordp_nmw(t, curwin)) {
continue;
+ }
}
}
word[wordlen++] = c;
@@ -6305,7 +6313,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
continue;
++k;
}
- s = smp[n].sm_rules;
+ char_u *s = smp[n].sm_rules;
pri = 5; // default priority
p0 = *s;
@@ -6704,25 +6712,30 @@ soundalike_score (
// support multi-byte characters.
static int spell_edit_score(slang_T *slang, char_u *badword, char_u *goodword)
{
- int *cnt;
- int badlen, goodlen; // lengths including NUL
+ int *cnt;
int j, i;
int t;
int bc, gc;
int pbc, pgc;
- char_u *p;
int wbadword[MAXWLEN];
int wgoodword[MAXWLEN];
const bool l_has_mbyte = has_mbyte;
+ // Lengths with NUL.
+ int badlen;
+ int goodlen;
if (l_has_mbyte) {
// Get the characters from the multi-byte strings and put them in an
// int array for easy access.
- for (p = badword, badlen = 0; *p != NUL; )
+ badlen = 0;
+ for (const char_u *p = badword; *p != NUL; ) {
wbadword[badlen++] = mb_cptr2char_adv(&p);
+ }
wbadword[badlen++] = 0;
- for (p = goodword, goodlen = 0; *p != NUL; )
+ goodlen = 0;
+ for (const char_u *p = goodword; *p != NUL; ) {
wgoodword[goodlen++] = mb_cptr2char_adv(&p);
+ }
wgoodword[goodlen++] = 0;
} else {
badlen = (int)STRLEN(badword) + 1;
@@ -6956,19 +6969,20 @@ static int spell_edit_score_limit_w(slang_T *slang, char_u *badword, char_u *goo
int score_off;
int minscore;
int round;
- char_u *p;
int wbadword[MAXWLEN];
int wgoodword[MAXWLEN];
// Get the characters from the multi-byte strings and put them in an
// int array for easy access.
bi = 0;
- for (p = badword; *p != NUL; )
+ for (const char_u *p = badword; *p != NUL; ) {
wbadword[bi++] = mb_cptr2char_adv(&p);
+ }
wbadword[bi++] = 0;
gi = 0;
- for (p = goodword; *p != NUL; )
+ for (const char_u *p = goodword; *p != NUL; ) {
wgoodword[gi++] = mb_cptr2char_adv(&p);
+ }
wgoodword[gi++] = 0;
// The idea is to go from start to end over the words. So long as
@@ -7134,16 +7148,17 @@ void ex_spelldump(exarg_T *eap)
char_u *spl;
long dummy;
- if (no_spell_checking(curwin))
+ if (no_spell_checking(curwin)) {
return;
- get_option_value((char_u*)"spl", &dummy, &spl, OPT_LOCAL);
+ }
+ get_option_value((char_u *)"spl", &dummy, &spl, OPT_LOCAL);
// Create a new empty buffer in a new window.
do_cmdline_cmd("new");
// enable spelling locally in the new window
- set_option_value((char_u*)"spell", true, (char_u*)"", OPT_LOCAL);
- set_option_value((char_u*)"spl", dummy, spl, OPT_LOCAL);
+ set_option_value("spell", true, "", OPT_LOCAL);
+ set_option_value("spl", dummy, (char *)spl, OPT_LOCAL);
xfree(spl);
if (!bufempty()) {
generated by cgit (git 2.34.1) at 2025-06-11 01:58:21 +0000