mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-28 14:08:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: replace char_u with char

Browse Source 
Work on https://github.com/neovim/neovim/issues/459
This commit is contained in:
Dundar Göc
2022-08-26 23:11:25 +02:00
committed by dundargoc
parent 29b80f6f2e
commit bd22585061
53 changed files with 603 additions and 611 deletions
Download Patch File Download Diff File Expand all files Collapse all files

283
src/nvim/spellfile.c
View File

@@ -365,8 +365,8 @@ typedef struct affentry_S affentry_T;
// Affix entry from ".aff" file. Used for prefixes and suffixes.
struct affentry_S {
affentry_T *ae_next; // next affix with same name/number
char_u *ae_chop; // text to chop off basic word (can be NULL)
char_u *ae_add; // text to add to basic word (can be NULL)
char *ae_chop; // text to chop off basic word (can be NULL)
char *ae_add; // text to add to basic word (can be NULL)
char_u *ae_flags; // flags on the affix (can be NULL)
char_u *ae_cond; // condition (NULL for ".")
regprog_T *ae_prog; // regexp program for ae_cond or NULL
@@ -483,7 +483,7 @@ typedef struct spellinfo_S {
int si_memtot; // runtime memory used
int si_verbose; // verbose messages
int si_msg_count; // number of words added since last message
char_u *si_info; // info text chars or NULL
char *si_info; // info text chars or NULL
int si_region_count; // number of regions supported (1 when there
// are no regions)
char_u si_region_name[MAXREGIONS * 2 + 1];
@@ -493,8 +493,8 @@ typedef struct spellinfo_S {
garray_T si_rep; // list of fromto_T entries from REP lines
garray_T si_repsal; // list of fromto_T entries from REPSAL lines
garray_T si_sal; // list of fromto_T entries from SAL lines
char_u *si_sofofr; // SOFOFROM text
char_u *si_sofoto; // SOFOTO text
char *si_sofofr; // SOFOFROM text
char *si_sofoto; // SOFOTO text
int si_nosugfile; // NOSUGFILE item found
int si_nosplitsugs; // NOSPLITSUGS item found
int si_nocompoundsugs; // NOCOMPOUNDSUGS item found
@@ -504,16 +504,16 @@ typedef struct spellinfo_S {
time_t si_sugtime; // timestamp for .sug file
int si_rem_accents; // soundsalike: remove accents
garray_T si_map; // MAP info concatenated
char_u *si_midword; // MIDWORD chars or NULL
char *si_midword; // MIDWORD chars or NULL
int si_compmax; // max nr of words for compounding
int si_compminlen; // minimal length for compounding
int si_compsylmax; // max nr of syllables for compounding
int si_compoptions; // COMP_ flags
garray_T si_comppat; // CHECKCOMPOUNDPATTERN items, each stored as
// a string
char_u *si_compflags; // flags used for compounding
char *si_compflags; // flags used for compounding
char_u si_nobreak; // NOBREAK
char_u *si_syllable; // syllable string
char *si_syllable; // syllable string
garray_T si_prefcond; // table with conditions for postponed
// prefixes, each stored as a string
int si_newprefID; // current value for ah_newID
@@ -2046,11 +2046,11 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
bool found_map = false;
hashitem_T *hi;
int l;
int compminlen = 0; // COMPOUNDMIN value
int compsylmax = 0; // COMPOUNDSYLMAX value
int compoptions = 0; // COMP_ flags
int compmax = 0; // COMPOUNDWORDMAX value
char_u *compflags = NULL; // COMPOUNDFLAG and COMPOUNDRULE
int compminlen = 0; // COMPOUNDMIN value
int compsylmax = 0; // COMPOUNDSYLMAX value
int compoptions = 0; // COMP_ flags
int compmax = 0; // COMPOUNDWORDMAX value
char *compflags = NULL; // COMPOUNDFLAG and COMPOUNDRULE
// concatenated
char_u *midword = NULL; // MIDWORD value
char_u *syllable = NULL; // SYLLABLE value
@@ -2179,7 +2179,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
}
} else if (spell_info_item(items[0]) && itemcnt > 1) {
p = getroom(spin,
(spin->si_info == NULL ? 0 : STRLEN(spin->si_info))
(spin->si_info == NULL ? 0 : strlen(spin->si_info))
+ strlen(items[0])
+ strlen(items[1]) + 3, false);
if (spin->si_info != NULL) {
@@ -2189,9 +2189,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
STRCAT(p, items[0]);
STRCAT(p, " ");
STRCAT(p, items[1]);
spin->si_info = (char_u *)p;
spin->si_info = p;
} else if (is_aff_rule(items, itemcnt, "MIDWORD", 2) && midword == NULL) {
midword = (char_u *)getroom_save(spin, (char_u *)items[1]);
midword = (char_u *)getroom_save(spin, items[1]);
} else if (is_aff_rule(items, itemcnt, "TRY", 2)) {
// ignored, we look in the tree for what chars may appear
} else if ((is_aff_rule(items, itemcnt, "RAR", 2) // TODO(vim): remove "RAR" later
@@ -2253,7 +2253,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
p = getroom(spin, strlen(items[1]) + 2, false);
STRCPY(p, items[1]);
STRCAT(p, "+");
compflags = (char_u *)p;
compflags = p;
} else if (is_aff_rule(items, itemcnt, "COMPOUNDRULES", 2)) {
// We don't use the count, but do check that it's a number and
// not COMPOUNDRULE mistyped.
@@ -2268,7 +2268,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
// using a slash to separate them.
l = (int)strlen(items[1]) + 1;
if (compflags != NULL) {
l += (int)STRLEN(compflags) + 1;
l += (int)strlen(compflags) + 1;
}
p = getroom(spin, (size_t)l, false);
if (compflags != NULL) {
@@ -2276,7 +2276,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
STRCAT(p, "/");
}
STRCAT(p, items[1]);
compflags = (char_u *)p;
compflags = p;
}
} else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
&& compmax == 0) {
@@ -2325,12 +2325,12 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
}
if (i >= gap->ga_len) {
ga_grow(gap, 2);
((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, (char_u *)items[1]);
((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, (char_u *)items[2]);
((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[1]);
((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[2]);
}
} else if (is_aff_rule(items, itemcnt, "SYLLABLE", 2)
&& syllable == NULL) {
syllable = (char_u *)getroom_save(spin, (char_u *)items[1]);
syllable = (char_u *)getroom_save(spin, items[1]);
} else if (is_aff_rule(items, itemcnt, "NOBREAK", 1)) {
spin->si_nobreak = true;
} else if (is_aff_rule(items, itemcnt, "NOSPLITSUGS", 1)) {
@@ -2394,7 +2394,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
fname, lnum, items[1]);
}
STRCPY(cur_aff->ah_key, items[1]);
hash_add(tp, (char_u *)cur_aff->ah_key);
hash_add(tp, cur_aff->ah_key);
cur_aff->ah_combine = (*items[2] == 'Y');
}
@@ -2463,13 +2463,13 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
aff_entry = getroom(spin, sizeof(*aff_entry), true);
if (strcmp(items[2], "0") != 0) {
aff_entry->ae_chop = (char_u *)getroom_save(spin, (char_u *)items[2]);
aff_entry->ae_chop = getroom_save(spin, items[2]);
}
if (strcmp(items[3], "0") != 0) {
aff_entry->ae_add = (char_u *)getroom_save(spin, (char_u *)items[3]);
aff_entry->ae_add = getroom_save(spin, items[3]);
// Recognize flags on the affix: abcd/XYZ
aff_entry->ae_flags = (char_u *)vim_strchr((char *)aff_entry->ae_add, '/');
aff_entry->ae_flags = (char_u *)vim_strchr(aff_entry->ae_add, '/');
if (aff_entry->ae_flags != NULL) {
*aff_entry->ae_flags++ = NUL;
aff_process_flags(aff, aff_entry);
@@ -2478,15 +2478,15 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
// Don't use an affix entry with non-ASCII characters when
// "spin->si_ascii" is true.
if (!spin->si_ascii || !(has_non_ascii(aff_entry->ae_chop)
|| has_non_ascii(aff_entry->ae_add))) {
if (!spin->si_ascii || !(has_non_ascii((char_u *)aff_entry->ae_chop)
|| has_non_ascii((char_u *)aff_entry->ae_add))) {
aff_entry->ae_next = cur_aff->ah_first;
cur_aff->ah_first = aff_entry;
if (strcmp(items[4], ".") != 0) {
char_u buf[MAXLINELEN];
aff_entry->ae_cond = (char_u *)getroom_save(spin, (char_u *)items[4]);
aff_entry->ae_cond = (char_u *)getroom_save(spin, items[4]);
if (*items[0] == 'P') {
sprintf((char *)buf, "^%s", items[4]); // NOLINT(runtime/printf)
} else {
@@ -2512,17 +2512,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
// be empty or start with the same letter.
if (aff_entry->ae_chop != NULL
&& aff_entry->ae_add != NULL
&& aff_entry->ae_chop[utfc_ptr2len((char *)aff_entry->ae_chop)] ==
&& aff_entry->ae_chop[utfc_ptr2len(aff_entry->ae_chop)] ==
NUL) {
int c, c_up;
c = utf_ptr2char((char *)aff_entry->ae_chop);
c = utf_ptr2char(aff_entry->ae_chop);
c_up = SPELL_TOUPPER(c);
if (c_up != c
&& (aff_entry->ae_cond == NULL
|| utf_ptr2char((char *)aff_entry->ae_cond) == c)) {
p = (char *)aff_entry->ae_add
+ STRLEN(aff_entry->ae_add);
p = aff_entry->ae_add + strlen(aff_entry->ae_add);
MB_PTR_BACK(aff_entry->ae_add, p);
if (utf_ptr2char(p) == c_up) {
upper = true;
@@ -2535,7 +2534,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
if (aff_entry->ae_cond != NULL) {
char_u buf[MAXLINELEN];
onecap_copy((char_u *)items[4], buf, true);
aff_entry->ae_cond = (char_u *)getroom_save(spin, buf);
aff_entry->ae_cond = (char_u *)getroom_save(spin, (char *)buf);
if (aff_entry->ae_cond != NULL) {
sprintf((char *)buf, "^%s", aff_entry->ae_cond); // NOLINT(runtime/printf)
vim_regfree(aff_entry->ae_prog);
@@ -2563,14 +2562,14 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
idx = spin->si_prefcond.ga_len;
pp = GA_APPEND_VIA_PTR(char_u *, &spin->si_prefcond);
*pp = (aff_entry->ae_cond == NULL) ?
NULL : (char_u *)getroom_save(spin, aff_entry->ae_cond);
NULL : (char_u *)getroom_save(spin, (char *)aff_entry->ae_cond);
}
// Add the prefix to the prefix tree.
if (aff_entry->ae_add == NULL) {
p = "";
} else {
p = (char *)aff_entry->ae_add;
p = aff_entry->ae_add;
}
// PFX_FLAGS is a negative number, so that
@@ -2637,7 +2636,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
}
add_fromto(spin, items[0][3] == 'S'
? &spin->si_repsal
: &spin->si_rep, (char_u *)items[1], (char_u *)items[2]);
: &spin->si_rep, items[1], items[2]);
}
} else if (is_aff_rule(items, itemcnt, "MAP", 2)) {
// MAP item or count
@@ -2682,24 +2681,24 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
spin->si_rem_accents = sal_to_bool(items[2]);
} else {
// when "to" is "_" it means empty
add_fromto(spin, &spin->si_sal, (char_u *)items[1],
strcmp(items[2], "_") == 0 ? (char_u *)""
: (char_u *)items[2]);
add_fromto(spin, &spin->si_sal, items[1],
strcmp(items[2], "_") == 0 ? ""
: items[2]);
}
}
} else if (is_aff_rule(items, itemcnt, "SOFOFROM", 2)
&& sofofrom == NULL) {
sofofrom = (char_u *)getroom_save(spin, (char_u *)items[1]);
sofofrom = (char_u *)getroom_save(spin, items[1]);
} else if (is_aff_rule(items, itemcnt, "SOFOTO", 2)
&& sofoto == NULL) {
sofoto = (char_u *)getroom_save(spin, (char_u *)items[1]);
sofoto = (char_u *)getroom_save(spin, items[1]);
} else if (strcmp(items[0], "COMMON") == 0) {
int i;
for (i = 1; i < itemcnt; i++) {
if (HASHITEM_EMPTY(hash_find(&spin->si_commonwords, (char *)items[i]))) {
p = xstrdup(items[i]);
hash_add(&spin->si_commonwords, (char_u *)p);
hash_add(&spin->si_commonwords, p);
}
}
} else {
@@ -2762,8 +2761,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
}
if (syllable != NULL) {
aff_check_string((char *)spin->si_syllable, (char *)syllable, "SYLLABLE");
spin->si_syllable = syllable;
aff_check_string(spin->si_syllable, (char *)syllable, "SYLLABLE");
spin->si_syllable = (char *)syllable;
}
if (sofofrom != NULL || sofoto != NULL) {
@@ -2773,16 +2772,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
} else if (!GA_EMPTY(&spin->si_sal)) {
smsg(_("Both SAL and SOFO lines in %s"), fname);
} else {
aff_check_string((char *)spin->si_sofofr, (char *)sofofrom, "SOFOFROM");
aff_check_string((char *)spin->si_sofoto, (char *)sofoto, "SOFOTO");
spin->si_sofofr = sofofrom;
spin->si_sofoto = sofoto;
aff_check_string(spin->si_sofofr, (char *)sofofrom, "SOFOFROM");
aff_check_string(spin->si_sofoto, (char *)sofoto, "SOFOTO");
spin->si_sofofr = (char *)sofofrom;
spin->si_sofoto = (char *)sofoto;
}
}
if (midword != NULL) {
aff_check_string((char *)spin->si_midword, (char *)midword, "MIDWORD");
spin->si_midword = midword;
aff_check_string(spin->si_midword, (char *)midword, "MIDWORD");
spin->si_midword = (char *)midword;
}
xfree(pc);
@@ -2813,7 +2812,7 @@ static void aff_process_flags(afffile_T *affile, affentry_T *entry)
prevp = p;
flag = get_affitem(affile->af_flagtype, &p);
if (flag == affile->af_comppermit || flag == affile->af_compforbid) {
STRMOVE(prevp, p);
STRMOVE(prevp, (char *)p);
p = prevp;
if (flag == affile->af_comppermit) {
entry->ae_comppermit = true;
@@ -2896,13 +2895,13 @@ static unsigned get_affitem(int flagtype, char_u **pp)
return (unsigned)res;
}
// Process the "compflags" string used in an affix file and append it to
// spin->si_compflags.
// The processing involves changing the affix names to ID numbers, so that
// they fit in one byte.
static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compflags)
/// Process the "compflags" string used in an affix file and append it to
/// spin->si_compflags.
/// The processing involves changing the affix names to ID numbers, so that
/// they fit in one byte.
static void process_compflags(spellinfo_T *spin, afffile_T *aff, char *compflags)
{
char_u *p;
char *p;
char_u *prevp;
unsigned flag;
compitem_T *ci;
@@ -2915,9 +2914,9 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compfla
// Make room for the old and the new compflags, concatenated with a / in
// between. Processing it makes it shorter, but we don't know by how
// much, thus allocate the maximum.
len = (int)STRLEN(compflags) + 1;
len = (int)strlen(compflags) + 1;
if (spin->si_compflags != NULL) {
len += (int)STRLEN(spin->si_compflags) + 1;
len += (int)strlen(spin->si_compflags) + 1;
}
p = getroom(spin, (size_t)len, false);
if (spin->si_compflags != NULL) {
@@ -2925,20 +2924,20 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compfla
STRCAT(p, "/");
}
spin->si_compflags = p;
tp = p + STRLEN(p);
tp = (char_u *)p + strlen(p);
for (p = compflags; *p != NUL;) {
if (vim_strchr("/?*+[]", *p) != NULL) {
// Copy non-flag characters directly.
*tp++ = *p++;
*tp++ = (char_u)(*p++);
} else {
// First get the flag number, also checks validity.
prevp = p;
flag = get_affitem(aff->af_flagtype, &p);
prevp = (char_u *)p;
flag = get_affitem(aff->af_flagtype, (char_u **)&p);
if (flag != 0) {
// Find the flag in the hashtable. If it was used before, use
// the existing ID. Otherwise add a new entry.
STRLCPY(key, prevp, p - prevp + 1);
STRLCPY(key, prevp, (char_u *)p - prevp + 1);
hi = hash_find(&aff->af_comp, (char *)key);
if (!HASHITEM_EMPTY(hi)) {
id = HI2CI(hi)->ci_newID;
@@ -2953,7 +2952,7 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char_u *compfla
id = spin->si_newcompID--;
} while (vim_strchr("/?*+[]\\-^", id) != NULL);
ci->ci_newID = id;
hash_add(&aff->af_comp, ci->ci_key);
hash_add(&aff->af_comp, (char *)ci->ci_key);
}
*tp++ = (char_u)id;
}
@@ -3050,17 +3049,17 @@ static bool str_equal(char *s1, char *s2)
return strcmp(s1, s2) == 0;
}
// Add a from-to item to "gap". Used for REP and SAL items.
// They are stored case-folded.
static void add_fromto(spellinfo_T *spin, garray_T *gap, char_u *from, char_u *to)
/// Add a from-to item to "gap". Used for REP and SAL items.
/// They are stored case-folded.
static void add_fromto(spellinfo_T *spin, garray_T *gap, char *from, char *to)
{
char_u word[MAXWLEN];
fromto_T *ftp = GA_APPEND_VIA_PTR(fromto_T, gap);
(void)spell_casefold(curwin, from, (int)STRLEN(from), word, MAXWLEN);
ftp->ft_from = (char_u *)getroom_save(spin, word);
(void)spell_casefold(curwin, to, (int)STRLEN(to), word, MAXWLEN);
ftp->ft_to = (char_u *)getroom_save(spin, word);
(void)spell_casefold(curwin, (char_u *)from, (int)strlen(from), word, MAXWLEN);
ftp->ft_from = (char_u *)getroom_save(spin, (char *)word);
(void)spell_casefold(curwin, (char_u *)to, (int)strlen(to), word, MAXWLEN);
ftp->ft_to = (char_u *)getroom_save(spin, (char *)word);
}
/// Converts a boolean argument in a SAL line to true or false;
@@ -3107,13 +3106,13 @@ static void spell_free_aff(afffile_T *aff)
static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
{
hashtab_T ht;
char_u line[MAXLINELEN];
char line[MAXLINELEN];
char_u *p;
char_u *afflist;
char_u store_afflist[MAXWLEN];
int pfxlen;
bool need_affix;
char_u *dw;
char *dw;
char_u *pc;
char_u *w;
int l;
@@ -3161,7 +3160,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
}
// Remove CR, LF and white space from the end. White space halfway through
// the word is kept to allow multi-word terms like "et al.".
l = (int)STRLEN(line);
l = (int)strlen(line);
while (l > 0 && line[l - 1] <= ' ') {
l--;
}
@@ -3181,7 +3180,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
w = pc;
} else {
pc = NULL;
w = line;
w = (char_u *)line;
}
// Truncate the word at the "/", set "afflist" to what follows.
@@ -3189,7 +3188,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
afflist = NULL;
for (p = w; *p != NUL; MB_PTR_ADV(p)) {
if (*p == '\\' && (p[1] == '\\' || p[1] == '/')) {
STRMOVE(p, p + 1);
STRMOVE(p, (char *)p + 1);
} else if (*p == '/') {
*p = NUL;
afflist = p + 1;
@@ -3223,15 +3222,15 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
}
// Store the word in the hashtable to be able to find duplicates.
dw = (char_u *)getroom_save(spin, w);
dw = getroom_save(spin, (char *)w);
if (dw == NULL) {
retval = FAIL;
xfree(pc);
break;
}
hash = hash_hash(dw);
hi = hash_lookup(&ht, (const char *)dw, STRLEN(dw), hash);
hash = hash_hash((char_u *)dw);
hi = hash_lookup(&ht, (const char *)dw, strlen(dw), hash);
if (!HASHITEM_EMPTY(hi)) {
if (p_verbose > 0) {
smsg(_("Duplicate word in %s line %d: %s"),
@@ -3242,7 +3241,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
}
duplicate++;
} else {
hash_add_item(&ht, hi, dw, hash);
hash_add_item(&ht, hi, (char_u *)dw, hash);
}
flags = 0;
@@ -3427,7 +3426,7 @@ static void get_compflags(afffile_T *affile, char_u *afflist, char_u *store_affl
/// @param pfxlen nr of flags in "pfxlist" for prefixes, rest is compound flags
///
/// @return FAIL when out of memory.
static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afffile_T *affile,
static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffile_T *affile,
hashtab_T *ht, hashtab_T *xht, int condit, int flags, char_u *pfxlist,
int pfxlen)
{
@@ -3435,7 +3434,7 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
hashitem_T *hi;
affheader_T *ah;
affentry_T *ae;
char_u newword[MAXWLEN];
char newword[MAXWLEN];
int retval = OK;
int i, j;
char_u *p;
@@ -3445,7 +3444,7 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
bool need_affix;
char_u store_afflist[MAXWLEN];
char_u pfx_pfxlist[MAXWLEN];
size_t wordlen = STRLEN(word);
size_t wordlen = strlen(word);
int use_condit;
todo = (int)ht->ht_used;
@@ -3475,9 +3474,9 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
|| ae->ae_chop != NULL
|| ae->ae_flags != NULL)
&& (ae->ae_chop == NULL
|| STRLEN(ae->ae_chop) < wordlen)
|| strlen(ae->ae_chop) < wordlen)
&& (ae->ae_prog == NULL
|| vim_regexec_prog(&ae->ae_prog, false, word, (colnr_T)0))
|| vim_regexec_prog(&ae->ae_prog, false, (char_u *)word, (colnr_T)0))
&& (((condit & CONDIT_CFIX) == 0)
== ((condit & CONDIT_AFF) == 0
|| ae->ae_flags == NULL
@@ -3491,10 +3490,10 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
} else {
STRLCPY(newword, ae->ae_add, MAXWLEN);
}
p = word;
p = (char_u *)word;
if (ae->ae_chop != NULL) {
// Skip chop string.
i = mb_charlen(ae->ae_chop);
i = mb_charlen((char_u *)ae->ae_chop);
for (; i > 0; i--) {
MB_PTR_ADV(p);
}
@@ -3505,8 +3504,8 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
STRLCPY(newword, word, MAXWLEN);
if (ae->ae_chop != NULL) {
// Remove chop string.
p = newword + STRLEN(newword);
i = mb_charlen(ae->ae_chop);
p = (char_u *)newword + strlen(newword);
i = mb_charlen((char_u *)ae->ae_chop);
for (; i > 0; i--) {
MB_PTR_BACK(newword, p);
}
@@ -3674,8 +3673,8 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
{
FILE *fd;
long lnum = 0;
char_u rline[MAXLINELEN];
char_u *line;
char rline[MAXLINELEN];
char *line;
char_u *pc = NULL;
char_u *p;
int l;
@@ -3706,8 +3705,8 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
}
// Remove CR, LF and white space from the end.
l = (int)STRLEN(rline);
while (l > 0 && rline[l - 1] <= ' ') {
l = (int)strlen(rline);
while (l > 0 && (uint8_t)rline[l - 1] <= ' ') {
l--;
}
if (l == 0) {
@@ -3718,13 +3717,13 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
// Convert from "/encoding={encoding}" to 'encoding' when needed.
xfree(pc);
if (spin->si_conv.vc_type != CONV_NONE) {
pc = (char_u *)string_convert(&spin->si_conv, (char *)rline, NULL);
pc = (char_u *)string_convert(&spin->si_conv, rline, NULL);
if (pc == NULL) {
smsg(_("Conversion failure for word in %s line %ld: %s"),
fname, lnum, rline);
continue;
}
line = pc;
line = (char *)pc;
} else {
pc = NULL;
line = rline;
@@ -3744,7 +3743,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
// Setup for conversion to 'encoding'.
line += 9;
enc = enc_canonize((char *)line);
enc = enc_canonize(line);
if (!spin->si_ascii
&& convert_setup(&spin->si_conv, enc, p_enc) == FAIL) {
smsg(_("Conversion in %s not supported: from %s to %s"),
@@ -3762,11 +3761,11 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
fname, lnum, line);
} else {
line += 8;
if (STRLEN(line) > MAXREGIONS * 2) {
if (strlen(line) > MAXREGIONS * 2) {
smsg(_("Too many regions in %s line %ld: %s"),
fname, lnum, line);
} else {
spin->si_region_count = (int)STRLEN(line) / 2;
spin->si_region_count = (int)strlen(line) / 2;
STRCPY(spin->si_region_name, line);
// Adjust the mask for a word valid in all regions.
@@ -3785,7 +3784,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
regionmask = spin->si_region;
// Check for flags and region after a slash.
p = (char_u *)vim_strchr((char *)line, '/');
p = (char_u *)vim_strchr(line, '/');
if (p != NULL) {
*p++ = NUL;
while (*p != NUL) {
@@ -3818,7 +3817,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
}
// Skip non-ASCII words when "spin->si_ascii" is true.
if (spin->si_ascii && has_non_ascii(line)) {
if (spin->si_ascii && has_non_ascii((char_u *)line)) {
non_ascii++;
continue;
}
@@ -3883,9 +3882,9 @@ static void *getroom(spellinfo_T *spin, size_t len, bool align)
/// Make a copy of a string into memory allocated with getroom().
///
/// @return NULL when out of memory.
static char *getroom_save(spellinfo_T *spin, char_u *s)
static char *getroom_save(spellinfo_T *spin, char *s)
{
const size_t s_size = STRLEN(s) + 1;
const size_t s_size = strlen(s) + 1;
return memcpy(getroom(spin, s_size, false), s, s_size);
}
@@ -3936,20 +3935,20 @@ static bool valid_spell_word(const char *word, const char *end)
/// @param region supported region(s)
/// @param pfxlist list of prefix ids or null
/// @param need_affix only store word with affix id
static int store_word(spellinfo_T *spin, char_u *word, int flags, int region, const char_u *pfxlist,
static int store_word(spellinfo_T *spin, char *word, int flags, int region, const char_u *pfxlist,
bool need_affix)
{
int len = (int)STRLEN(word);
int ct = captype(word, word + len);
int len = (int)strlen(word);
int ct = captype((char_u *)word, (char_u *)word + len);
char_u foldword[MAXWLEN];
int res = OK;
// Avoid adding illegal bytes to the word tree.
if (!valid_spell_word((char *)word, (char *)word + len)) {
if (!valid_spell_word(word, word + len)) {
return FAIL;
}
(void)spell_casefold(curwin, word, len, foldword, MAXWLEN);
(void)spell_casefold(curwin, (char_u *)word, len, foldword, MAXWLEN);
for (const char_u *p = pfxlist; res == OK; p++) {
if (!need_affix || (p != NULL && *p != NUL)) {
res = tree_add_word(spin, foldword, spin->si_foldroot, ct | flags,
@@ -3964,7 +3963,7 @@ static int store_word(spellinfo_T *spin, char_u *word, int flags, int region, co
if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP))) {
for (const char_u *p = pfxlist; res == OK; p++) {
if (!need_affix || (p != NULL && *p != NUL)) {
res = tree_add_word(spin, word, spin->si_keeproot, flags,
res = tree_add_word(spin, (char_u *)word, spin->si_keeproot, flags,
region, p == NULL ? 0 : *p);
}
if (p == NULL || *p == NUL) {
@@ -4268,7 +4267,7 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
// Try to find an identical child.
hash = hash_hash(child->wn_u1.hashkey);
hi = hash_lookup(ht, (const char *)child->wn_u1.hashkey,
STRLEN(child->wn_u1.hashkey), hash);
strlen((char *)child->wn_u1.hashkey), hash);
if (!HASHITEM_EMPTY(hi)) {
// There are children we encountered before with a hash value
// identical to the current child. Now check if there is one
@@ -4394,7 +4393,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
if (spin->si_info != NULL) {
putc(SN_INFO, fd); // <sectionID>
putc(0, fd); // <sectionflags>
size_t i = STRLEN(spin->si_info);
size_t i = strlen(spin->si_info);
put_bytes(fd, i, 4); // <sectionlen>
fwv &= fwrite(spin->si_info, i, 1, fd); // <infotext>
}
@@ -4457,7 +4456,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
putc(SN_MIDWORD, fd); // <sectionID>
putc(SNF_REQUIRED, fd); // <sectionflags>
size_t i = STRLEN(spin->si_midword);
size_t i = strlen(spin->si_midword);
put_bytes(fd, i, 4); // <sectionlen>
fwv &= fwrite(spin->si_midword, i, 1, fd);
// <midword>
@@ -4517,8 +4516,8 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
assert(gap->ga_len >= 0);
for (size_t i = 0; i < (size_t)gap->ga_len; i++) {
fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
l += 1 + STRLEN(ftp->ft_from); // count <*fromlen> and <*from>
l += 1 + STRLEN(ftp->ft_to); // count <*tolen> and <*to>
l += 1 + strlen((char *)ftp->ft_from); // count <*fromlen> and <*from>
l += 1 + strlen((char *)ftp->ft_to); // count <*tolen> and <*to>
}
if (round == 2) {
l++; // count <salflags>
@@ -4545,8 +4544,8 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
// <sal> : <salfromlen> <salfrom> <saltolen> <salto>
fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
for (unsigned int rr = 1; rr <= 2; rr++) {
char_u *p = rr == 1 ? ftp->ft_from : ftp->ft_to;
l = STRLEN(p);
char *p = rr == 1 ? (char *)ftp->ft_from : (char *)ftp->ft_to;
l = strlen(p);
assert(l < INT_MAX);
putc((int)l, fd);
if (l > 0) {
@@ -4562,13 +4561,13 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
putc(SN_SOFO, fd); // <sectionID>
putc(0, fd); // <sectionflags>
size_t l = STRLEN(spin->si_sofofr);
put_bytes(fd, l + STRLEN(spin->si_sofoto) + 4, 4); // <sectionlen>
size_t l = strlen(spin->si_sofofr);
put_bytes(fd, l + strlen(spin->si_sofoto) + 4, 4); // <sectionlen>
put_bytes(fd, l, 2); // <sofofromlen>
fwv &= fwrite(spin->si_sofofr, l, 1, fd); // <sofofrom>
l = STRLEN(spin->si_sofoto);
l = strlen(spin->si_sofoto);
put_bytes(fd, l, 2); // <sofotolen>
fwv &= fwrite(spin->si_sofoto, l, 1, fd); // <sofoto>
}
@@ -4589,7 +4588,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
todo = spin->si_commonwords.ht_used;
for (hi = spin->si_commonwords.ht_array; todo > 0; hi++) {
if (!HASHITEM_EMPTY(hi)) {
size_t l = STRLEN(hi->hi_key) + 1;
size_t l = strlen(hi->hi_key) + 1;
len += l;
if (round == 2) { // <word>
fwv &= fwrite(hi->hi_key, l, 1, fd);
@@ -4655,7 +4654,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
putc(SN_COMPOUND, fd); // <sectionID>
putc(0, fd); // <sectionflags>
size_t l = STRLEN(spin->si_compflags);
size_t l = strlen(spin->si_compflags);
assert(spin->si_comppat.ga_len >= 0);
for (size_t i = 0; i < (size_t)spin->si_comppat.ga_len; i++) {
l += strlen(((char **)(spin->si_comppat.ga_data))[i]) + 1;
@@ -4675,7 +4674,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
fwv &= fwrite(p, strlen(p), 1, fd); // <comppattext>
}
// <compflags>
fwv &= fwrite(spin->si_compflags, STRLEN(spin->si_compflags), 1, fd);
fwv &= fwrite(spin->si_compflags, strlen(spin->si_compflags), 1, fd);
}
// SN_NOBREAK: NOBREAK flag
@@ -4694,7 +4693,7 @@ static int write_vim_spell(spellinfo_T *spin, char *fname)
putc(SN_SYLLABLE, fd); // <sectionID>
putc(0, fd); // <sectionflags>
size_t l = STRLEN(spin->si_syllable);
size_t l = strlen(spin->si_syllable);
put_bytes(fd, l, 4); // <sectionlen>
fwv &= fwrite(spin->si_syllable, l, 1, fd); // <syllable>
}
@@ -4913,7 +4912,7 @@ void ex_mkspell(exarg_T *eap)
// Writes the file with the name "wfname", with ".spl" changed to ".sug".
static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
{
char_u *fname = NULL;
char *fname = NULL;
int len;
slang_T *slang;
bool free_slang = false;
@@ -4972,10 +4971,10 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
// Make the file name by changing ".spl" to ".sug".
fname = xmalloc(MAXPATHL);
STRLCPY(fname, wfname, MAXPATHL);
len = (int)STRLEN(fname);
len = (int)strlen(fname);
fname[len - 2] = 'u';
fname[len - 1] = 'g';
sug_write(spin, fname);
sug_write(spin, (char_u *)fname);
theend:
xfree(fname);
@@ -5036,7 +5035,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
if (c == 0) {
// Sound-fold the word.
tword[depth] = NUL;
spell_soundfold(slang, tword, true, tsalword);
spell_soundfold(slang, (char *)tword, true, (char *)tsalword);
// We use the "flags" field for the MSB of the wordnr,
// "region" for the LSB of the wordnr.
@@ -5250,8 +5249,8 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
for (linenr_T lnum = 1; lnum <= wcount; lnum++) {
// <sugline>: <sugnr> ... NUL
char_u *line = (char_u *)ml_get_buf(spin->si_spellbuf, lnum, false);
size_t len = STRLEN(line) + 1;
char *line = ml_get_buf(spin->si_spellbuf, lnum, false);
size_t len = strlen(line) + 1;
if (fwrite(line, len, 1, fd) == 0) {
emsg(_(e_write));
goto theend;
@@ -5316,7 +5315,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
char *wfname = xmalloc(MAXPATHL);
if (fcount >= 1) {
len = (int)STRLEN(fnames[0]);
len = (int)strlen(fnames[0]);
if (fcount == 1 && len > 4 && strcmp(fnames[0] + len - 4, ".add") == 0) {
// For ":mkspell path/en.latin1.add" output file is
// "path/en.latin1.add.spl".
@@ -5689,7 +5688,7 @@ void spell_add_word(char_u *word, int len, SpellAddType what, int idx, bool undo
// Initialize 'spellfile' for the current buffer.
static void init_spellfile(void)
{
char_u *buf;
char *buf;
int l;
char_u *fname;
char_u *rtp;
@@ -5720,29 +5719,29 @@ static void init_spellfile(void)
STRLCPY(buf, curbuf->b_s.b_p_spl, lstart - (char_u *)curbuf->b_s.b_p_spl);
} else {
// Copy the path from 'runtimepath' to buf[].
copy_option_part((char **)&rtp, (char *)buf, MAXPATHL, ",");
copy_option_part((char **)&rtp, buf, MAXPATHL, ",");
}
if (os_file_is_writable((char *)buf) == 2) {
if (os_file_is_writable(buf) == 2) {
// Use the first language name from 'spelllang' and the
// encoding used in the first loaded .spl file.
if (aspath) {
STRLCPY(buf, curbuf->b_s.b_p_spl, lend - (char_u *)curbuf->b_s.b_p_spl + 1);
} else {
// Create the "spell" directory if it doesn't exist yet.
l = (int)STRLEN(buf);
vim_snprintf((char *)buf + l, MAXPATHL - (size_t)l, "/spell");
if (os_file_is_writable((char *)buf) != 2) {
os_mkdir((char *)buf, 0755);
l = (int)strlen(buf);
vim_snprintf(buf + l, MAXPATHL - (size_t)l, "/spell");
if (os_file_is_writable(buf) != 2) {
os_mkdir(buf, 0755);
}
l = (int)STRLEN(buf);
vim_snprintf((char *)buf + l, MAXPATHL - (size_t)l,
l = (int)strlen(buf);
vim_snprintf(buf + l, MAXPATHL - (size_t)l,
"/%.*s", (int)(lend - lstart), lstart);
}
l = (int)STRLEN(buf);
l = (int)strlen(buf);
fname = (char_u *)LANGP_ENTRY(curwin->w_s->b_langp, 0)
->lp_slang->sl_fname;
vim_snprintf((char *)buf + l, MAXPATHL - (size_t)l, ".%s.add",
vim_snprintf(buf + l, MAXPATHL - (size_t)l, ".%s.add",
((fname != NULL
&& strstr(path_tail((char *)fname), ".ascii.") != NULL)
? "ascii"