kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-01-01 17:23:36 -07:00
Code Issues Packages Projects Releases Wiki Activity

refactor: replace char_u with char 17 - remove STRLCPY (#21235)

Browse Source 
refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
This commit is contained in:
dundargoc 2023-01-09 14:13:06 +01:00 committed by GitHub
parent fc2cd28547
commit 1492094003
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
43 changed files with 230 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/nvim/buffer.c
View File

@ -2760,7 +2760,7 @@ void buflist_list(exarg_T *eap)
continue;
}
if (buf_spname(buf) != NULL) {
STRLCPY(NameBuff, buf_spname(buf), MAXPATHL);
xstrlcpy(NameBuff, buf_spname(buf), MAXPATHL);
} else {
home_replace(buf, buf->b_fname, (char *)NameBuff, MAXPATHL, true);
}
@ -3110,7 +3110,7 @@ void fileinfo(int fullname, int shorthelp, int dont_truncate)
*p++ = '"';
if (buf_spname(curbuf) != NULL) {
STRLCPY(p, buf_spname(curbuf), IOSIZE - (p - buffer));
xstrlcpy(p, buf_spname(curbuf), (size_t)(IOSIZE - (p - buffer)));
} else {
if (!fullname && curbuf->b_fname != NULL) {
name = curbuf->b_fname;
@ -3436,9 +3436,9 @@ void get_rel_pos(win_T *wp, char *buf, int buflen)
}
below = wp->w_buffer->b_ml.ml_line_count - wp->w_botline + 1;
if (below <= 0) {
STRLCPY(buf, (above == 0 ? _("All") : _("Bot")), buflen);
xstrlcpy(buf, (above == 0 ? _("All") : _("Bot")), (size_t)buflen);
} else if (above <= 0) {
STRLCPY(buf, _("Top"), buflen);
xstrlcpy(buf, _("Top"), (size_t)buflen);
} else {
vim_snprintf(buf, (size_t)buflen, "%2d%%", above > 1000000L
? (int)(above / ((above + below) / 100L))

2
src/nvim/change.c
View File

@ -1433,7 +1433,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
leader = xmalloc((size_t)bytes);
allocated = leader; // remember to free it later
STRLCPY(leader, saved_line, lead_len + 1);
xstrlcpy(leader, saved_line, (size_t)lead_len + 1);
// TODO(vim): handle multi-byte and double width chars
for (int li = 0; li < comment_start; li++) {

6
src/nvim/cmdexpand.c
View File

@ -1162,7 +1162,7 @@ char *addstar(char *fname, size_t len, int context)
}
} else {
retval = xmalloc(len + 4);
STRLCPY(retval, fname, len + 1);
xstrlcpy(retval, fname, len + 1);
// Don't add a star to *, ~, ~user, $var or `cmd`.
// * would become **, which walks the whole tree.
@ -2650,10 +2650,10 @@ static void expand_shellcmd(char *filepat, int *num_file, char ***file, int flag
if (l > MAXPATHL - 5) {
break;
}
STRLCPY(buf, s, l + 1);
xstrlcpy(buf, s, l + 1);
add_pathsep(buf);
l = strlen(buf);
STRLCPY(buf + l, pat, MAXPATHL - l);
xstrlcpy(buf + l, pat, MAXPATHL - l);
// Expand matches in one directory of $PATH.
ret = expand_wildcards(1, &buf, num_file, file, flags);

2
src/nvim/diff.c
View File

@ -1230,7 +1230,7 @@ void ex_diffpatch(exarg_T *eap)
// have our own temp dir use that instead, it will be cleaned up when we
// exit (any .rej files created). Don't change directory if we can't
// return to the current.
if ((os_dirname((char_u *)dirbuf, MAXPATHL) != OK)
if ((os_dirname(dirbuf, MAXPATHL) != OK)
|| (os_chdir(dirbuf) != 0)) {
dirbuf[0] = NUL;
} else {

2
src/nvim/drawline.c
View File

@ -708,7 +708,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
nextline[SPWORDLEN] = NUL;
if (lnum < wp->w_buffer->b_ml.ml_line_count) {
line = ml_get_buf(wp->w_buffer, lnum + 1, false);
spell_cat_line((char_u *)nextline + SPWORDLEN, (char_u *)line, SPWORDLEN);
spell_cat_line(nextline + SPWORDLEN, (char_u *)line, SPWORDLEN);
}
// When a word wrapped from the previous line the start of the current

2
src/nvim/eval.c
View File

@ -7861,7 +7861,7 @@ repeat:
if (p != NULL) {
if (c == '.') {
os_dirname((char_u *)dirname, MAXPATHL);
os_dirname(dirname, MAXPATHL);
if (has_homerelative) {
s = xstrdup(dirname);
home_replace(NULL, s, dirname, MAXPATHL, true);

6
src/nvim/eval/funcs.c
View File

@ -822,7 +822,7 @@ static void f_chdir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
// Return the current directory
char *cwd = xmalloc(MAXPATHL);
if (os_dirname((char_u *)cwd, MAXPATHL) != FAIL) {
if (os_dirname(cwd, MAXPATHL) != FAIL) {
#ifdef BACKSLASH_IN_FILENAME
slash_adjust(cwd);
#endif
@ -2517,13 +2517,13 @@ static void f_getcwd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
}
FALLTHROUGH; // In global directory, just need to get OS CWD.
case kCdScopeInvalid: // If called without any arguments, get OS CWD.
if (os_dirname((char_u *)cwd, MAXPATHL) == FAIL) {
if (os_dirname(cwd, MAXPATHL) == FAIL) {
from = ""; // Return empty string on failure.
}
}
if (from) {
STRLCPY(cwd, from, MAXPATHL);
xstrlcpy(cwd, from, MAXPATHL);
}
rettv->vval.v_string = xstrdup(cwd);

18
src/nvim/eval/userfunc.c
View File

@ -260,7 +260,7 @@ int get_lambda_tv(char **arg, typval_T *rettv, bool evaluate)
int varargs;
int ret;
char_u *start = (char_u *)skipwhite(*arg + 1);
char_u *s, *e;
char *s, *e;
bool *old_eval_lavars = eval_lavars_used;
bool eval_lavars = false;
@ -289,12 +289,12 @@ int get_lambda_tv(char **arg, typval_T *rettv, bool evaluate)
// Get the start and the end of the expression.
*arg = skipwhite((*arg) + 1);
s = (char_u *)(*arg);
s = *arg;
ret = skip_expr(arg);
if (ret == FAIL) {
goto errret;
}
e = (char_u *)(*arg);
e = *arg;
*arg = skipwhite(*arg);
if (**arg != '}') {
semsg(_("E451: Expected }: %s"), *arg);
@ -304,7 +304,7 @@ int get_lambda_tv(char **arg, typval_T *rettv, bool evaluate)
if (evaluate) {
int flags = 0;
char_u *p;
char *p;
garray_T newlines;
char *name = (char *)get_lambda_name();
@ -317,11 +317,11 @@ int get_lambda_tv(char **arg, typval_T *rettv, bool evaluate)
// Add "return " before the expression.
size_t len = (size_t)(7 + e - s + 1);
p = (char_u *)xmalloc(len);
((char **)(newlines.ga_data))[newlines.ga_len++] = (char *)p;
p = xmalloc(len);
((char **)(newlines.ga_data))[newlines.ga_len++] = p;
STRCPY(p, "return ");
STRLCPY(p + 7, s, e - s + 1);
if (strstr((char *)p + 7, "a:") == NULL) {
xstrlcpy(p + 7, s, (size_t)(e - s) + 1);
if (strstr(p + 7, "a:") == NULL) {
// No a: variables are used for sure.
flags |= FC_NOARGS;
}
@ -3214,7 +3214,7 @@ char *get_return_cmd(void *rettv)
}
STRCPY(IObuff, ":return ");
STRLCPY(IObuff + 8, s, IOSIZE - 8);
xstrlcpy(IObuff + 8, s, IOSIZE - 8);
if (strlen(s) + 8 >= IOSIZE) {
STRCPY(IObuff + IOSIZE - 4, "...");
}

4
src/nvim/eval/window.h
View File

@ -31,13 +31,13 @@ typedef struct {
&& (curwin->w_localdir != NULL || wp->w_localdir != NULL \
|| (curtab != tp && (curtab->tp_localdir != NULL || tp->tp_localdir != NULL)) \
|| p_acd)) { \
cwd_status_ = os_dirname((char_u *)cwd_, MAXPATHL); \
cwd_status_ = os_dirname(cwd_, MAXPATHL); \
} \
/* If 'acd' is set, check we are using that directory. If yes, then */ \
/* apply 'acd' afterwards, otherwise restore the current directory. */ \
if (cwd_status_ == OK && p_acd) { \
do_autochdir(); \
apply_acd_ = os_dirname((char_u *)autocwd_, MAXPATHL) == OK && strcmp(cwd_, autocwd_) == 0; \
apply_acd_ = os_dirname(autocwd_, MAXPATHL) == OK && strcmp(cwd_, autocwd_) == 0; \
} \
switchwin_T switchwin_; \
if (switch_win_noblock(&switchwin_, wp_, (tp), true) == OK) { \

10
src/nvim/ex_docmd.c
View File

@ -5104,7 +5104,7 @@ static void ex_tabs(exarg_T *eap)
msg_putchar(bufIsChanged(wp->w_buffer) ? '+' : ' ');
msg_putchar(' ');
if (buf_spname(wp->w_buffer) != NULL) {
STRLCPY(IObuff, buf_spname(wp->w_buffer), IOSIZE);
xstrlcpy(IObuff, buf_spname(wp->w_buffer), IOSIZE);
} else {
home_replace(wp->w_buffer, wp->w_buffer->b_fname, (char *)IObuff, IOSIZE, true);
}
@ -5497,7 +5497,7 @@ static void post_chdir(CdScope scope, bool trigger_dirchanged)
}
char cwd[MAXPATHL];
if (os_dirname((char_u *)cwd, MAXPATHL) != OK) {
if (os_dirname(cwd, MAXPATHL) != OK) {
return;
}
switch (scope) {
@ -5544,7 +5544,7 @@ bool changedir_func(char *new_dir, CdScope scope)
new_dir = pdir;
}
if (os_dirname((char_u *)NameBuff, MAXPATHL) == OK) {
if (os_dirname(NameBuff, MAXPATHL) == OK) {
pdir = xstrdup(NameBuff);
} else {
pdir = NULL;
@ -5627,7 +5627,7 @@ void ex_cd(exarg_T *eap)
/// ":pwd".
static void ex_pwd(exarg_T *eap)
{
if (os_dirname((char_u *)NameBuff, MAXPATHL) == OK) {
if (os_dirname(NameBuff, MAXPATHL) == OK) {
#ifdef BACKSLASH_IN_FILENAME
slash_adjust(NameBuff);
#endif
@ -6851,7 +6851,7 @@ char_u *eval_vars(char_u *src, const char_u *srcstart, size_t *usedlen, linenr_T
// postponed to avoid a delay when <afile> is not used.
result = FullName_save(autocmd_fname, false);
// Copy into `autocmd_fname`, don't reassign it. #8165
STRLCPY(autocmd_fname, result, MAXPATHL);
xstrlcpy(autocmd_fname, result, MAXPATHL);
xfree(result);
}
result = autocmd_fname;

2
src/nvim/ex_eval.c
View File

@ -559,7 +559,7 @@ static void discard_exception(except_T *excp, bool was_finished)
} else {
verbose_leave();
}
STRLCPY(IObuff, saved_IObuff, IOSIZE);
xstrlcpy(IObuff, saved_IObuff, IOSIZE);
xfree(saved_IObuff);
}
if (excp->type != ET_INTERRUPT) {

2
src/nvim/ex_session.c
View File

@ -1007,7 +1007,7 @@ void ex_mkrc(exarg_T *eap)
//
// Change to session file's dir.
//
if (os_dirname(dirnow, MAXPATHL) == FAIL
if (os_dirname((char *)dirnow, MAXPATHL) == FAIL
|| os_chdir((char *)dirnow) != 0) {
*dirnow = NUL;
}

12
src/nvim/file_search.c
View File

@ -290,7 +290,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
if (!vim_isAbsName((char_u *)rel_fname) && len + 1 < MAXPATHL) {
// Make the start dir an absolute path name.
STRLCPY(ff_expand_buffer, rel_fname, len + 1);
xstrlcpy(ff_expand_buffer, rel_fname, len + 1);
search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer, false);
} else {
search_ctx->ffsc_start_dir = xstrnsave(rel_fname, len);
@ -315,7 +315,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
path += 2;
} else // NOLINT(readability/braces)
#endif
if (os_dirname((char_u *)ff_expand_buffer, MAXPATHL) == FAIL) {
if (os_dirname(ff_expand_buffer, MAXPATHL) == FAIL) {
goto error_return;
}
@ -815,7 +815,7 @@ char_u *vim_findfile(void *search_ctx_arg)
if (!path_with_url(file_path)) {
simplify_filename((char_u *)file_path);
}
if (os_dirname((char_u *)ff_expand_buffer, MAXPATHL) == OK) {
if (os_dirname(ff_expand_buffer, MAXPATHL) == OK) {
p = path_shorten_fname(file_path, ff_expand_buffer);
if (p != NULL) {
STRMOVE(file_path, p);
@ -1071,7 +1071,7 @@ static int ff_check_visited(ff_visited_T **visited_list, char *fname, char *wc_p
// For a URL we only compare the name, otherwise we compare the
// device/inode.
if (path_with_url(fname)) {
STRLCPY(ff_expand_buffer, fname, MAXPATHL);
xstrlcpy(ff_expand_buffer, fname, MAXPATHL);
url = true;
} else {
ff_expand_buffer[0] = NUL;
@ -1580,10 +1580,10 @@ int vim_chdirfile(char *fname, CdCause cause)
{
char dir[MAXPATHL];
STRLCPY(dir, fname, MAXPATHL);
xstrlcpy(dir, fname, MAXPATHL);
*path_tail_with_sep(dir) = NUL;
if (os_dirname((char_u *)NameBuff, sizeof(NameBuff)) != OK) {
if (os_dirname(NameBuff, sizeof(NameBuff)) != OK) {
NameBuff[0] = NUL;
}

4
src/nvim/fileio.c
View File

@ -4234,7 +4234,7 @@ void shorten_fnames(int force)
{
char_u dirname[MAXPATHL];
os_dirname(dirname, MAXPATHL);
os_dirname((char *)dirname, MAXPATHL);
FOR_ALL_BUFFERS(buf) {
shorten_buf_fname(buf, dirname, force);
@ -4281,7 +4281,7 @@ char *modname(const char *fname, const char *ext, bool prepend_dot)
// (we need the full path in case :cd is used).
if (fname == NULL || *fname == NUL) {
retval = xmalloc(MAXPATHL + extlen + 3); // +3 for PATHSEP, "_" (Win), NUL
if (os_dirname((char_u *)retval, MAXPATHL) == FAIL
if (os_dirname(retval, MAXPATHL) == FAIL
|| strlen(retval) == 0) {
xfree(retval);
return NULL;

2
src/nvim/fold.c
View File

@ -1615,7 +1615,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char *marker, size_t mark
STRCPY(newline, line);
// Append the marker to the end of the line
if (p == NULL || line_is_comment) {
STRLCPY(newline + line_len, marker, markerlen + 1);
xstrlcpy(newline + line_len, marker, markerlen + 1);
added = markerlen;
} else {
STRCPY(newline + line_len, cms);

4
src/nvim/getchar.c
View File

@ -244,7 +244,7 @@ static void add_buff(buffheader_T *const buf, const char *const s, ptrdiff_t sle
size_t len;
if (buf->bh_space >= (size_t)slen) {
len = strlen(buf->bh_curr->b_str);
STRLCPY(buf->bh_curr->b_str + len, s, slen + 1);
xstrlcpy(buf->bh_curr->b_str + len, s, (size_t)slen + 1);
buf->bh_space -= (size_t)slen;
} else {
if (slen < MINIMAL_SIZE) {
@ -254,7 +254,7 @@ static void add_buff(buffheader_T *const buf, const char *const s, ptrdiff_t sle
}
buffblock_T *p = xmalloc(sizeof(buffblock_T) + len);
buf->bh_space = len - (size_t)slen;
STRLCPY(p->b_str, s, slen + 1);
xstrlcpy(p->b_str, s, (size_t)slen + 1);
p->b_next = buf->bh_curr->b_next;
buf->bh_curr->b_next = p;

4
src/nvim/help.c
View File

@ -880,7 +880,7 @@ static void helptags_one(char *dir, const char *ext, const char *tagfname, bool
bool mix = false; // detected mixed encodings
// Find all *.txt files.
size_t dirlen = STRLCPY(NameBuff, dir, sizeof(NameBuff));
size_t dirlen = xstrlcpy(NameBuff, dir, sizeof(NameBuff));
if (dirlen >= MAXPATHL
|| xstrlcat(NameBuff, "/**/*", sizeof(NameBuff)) >= MAXPATHL // NOLINT
|| xstrlcat(NameBuff, ext, sizeof(NameBuff)) >= MAXPATHL) {
@ -1089,7 +1089,7 @@ static void do_helptags(char *dirname, bool add_help_tags, bool ignore_writeerr)
char **files;
// Get a list of all files in the help directory and in subdirectories.
STRLCPY(NameBuff, dirname, sizeof(NameBuff));
xstrlcpy(NameBuff, dirname, sizeof(NameBuff));
if (!add_pathsep((char *)NameBuff)
|| xstrlcat(NameBuff, "**", sizeof(NameBuff)) >= MAXPATHL) {
emsg(_(e_fnametoolong));

2
src/nvim/insexpand.c
View File

@ -3106,7 +3106,7 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
if (tmp_ptr - ptr >= IOSIZE - len) {
tmp_ptr = ptr + IOSIZE - len - 1;
}
STRLCPY(IObuff + len, ptr, IOSIZE - len);
xstrlcpy(IObuff + len, ptr, (size_t)(IOSIZE - len));
len += (int)(tmp_ptr - ptr);
*cont_s_ipos = true;
}

16
src/nvim/mapping.c
View File

@ -271,7 +271,7 @@ static bool set_maparg_lhs_rhs(const char *const orig_lhs, const size_t orig_lhs
return false;
}
mapargs->lhs_len = strlen(replaced);
STRLCPY(mapargs->lhs, replaced, sizeof(mapargs->lhs));
xstrlcpy(mapargs->lhs, replaced, sizeof(mapargs->lhs));
if (did_simplify) {
replaced = replace_termcodes(orig_lhs, orig_lhs_len, &bufarg, flags | REPTERM_NO_SIMPLIFY,
NULL, cpo_flags);
@ -279,7 +279,7 @@ static bool set_maparg_lhs_rhs(const char *const orig_lhs, const size_t orig_lhs
return false;
}
mapargs->alt_lhs_len = strlen(replaced);
STRLCPY(mapargs->alt_lhs, replaced, sizeof(mapargs->alt_lhs));
xstrlcpy(mapargs->alt_lhs, replaced, sizeof(mapargs->alt_lhs));
} else {
mapargs->alt_lhs_len = 0;
}
@ -298,7 +298,7 @@ static void set_maparg_rhs(const char *const orig_rhs, const size_t orig_rhs_len
if (rhs_lua == LUA_NOREF) {
mapargs->orig_rhs_len = orig_rhs_len;
mapargs->orig_rhs = xcalloc(mapargs->orig_rhs_len + 1, sizeof(char_u));
STRLCPY(mapargs->orig_rhs, orig_rhs, mapargs->orig_rhs_len + 1);
xstrlcpy(mapargs->orig_rhs, orig_rhs, mapargs->orig_rhs_len + 1);
if (STRICMP(orig_rhs, "<nop>") == 0) { // "<Nop>" means nothing
mapargs->rhs = xcalloc(1, sizeof(char_u)); // single NUL-char
mapargs->rhs_len = 0;
@ -427,11 +427,11 @@ static int str_to_mapargs(const char_u *strargs, bool is_unmap, MapArguments *ma
if (orig_lhs_len >= 256) {
return 1;
}
char_u lhs_to_replace[256];
STRLCPY(lhs_to_replace, to_parse, orig_lhs_len + 1);
char lhs_to_replace[256];
xstrlcpy(lhs_to_replace, to_parse, orig_lhs_len + 1);
size_t orig_rhs_len = strlen(rhs_start);
if (!set_maparg_lhs_rhs((char *)lhs_to_replace, orig_lhs_len,
if (!set_maparg_lhs_rhs(lhs_to_replace, orig_lhs_len,
rhs_start, orig_rhs_len, LUA_NOREF,
CPO_TO_CPO_FLAGS, mapargs)) {
return 1;
@ -464,7 +464,7 @@ static void map_add(buf_T *buf, mapblock_T **map_table, mapblock_T **abbr_table,
mp->m_keys = xstrdup(keys);
mp->m_str = args->rhs;
mp->m_orig_str = (char *)args->orig_rhs;
mp->m_orig_str = args->orig_rhs;
mp->m_luaref = args->rhs_lua;
if (!simplified) {
args->rhs = NULL;
@ -776,7 +776,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
XFREE_CLEAR(mp->m_orig_str);
}
mp->m_str = args->rhs;
mp->m_orig_str = (char *)args->orig_rhs;
mp->m_orig_str = args->orig_rhs;
mp->m_luaref = args->rhs_lua;
if (!keyround1_simplified) {
args->rhs = NULL;

6
src/nvim/mapping.h
View File

@ -32,11 +32,11 @@ struct map_arguments {
/// vim limits this to MAXMAPLEN characters, allowing us to use a static
/// buffer. Setting lhs_len to a value larger than MAXMAPLEN can signal
/// that {lhs} was too long and truncated.
char_u lhs[MAXMAPLEN + 1];
char lhs[MAXMAPLEN + 1];
size_t lhs_len;
/// Unsimplifed {lhs} of the mapping. If no simplification has been done then alt_lhs_len is 0.
char_u alt_lhs[MAXMAPLEN + 1];
char alt_lhs[MAXMAPLEN + 1];
size_t alt_lhs_len;
char *rhs; /// The {rhs} of the mapping.
@ -44,7 +44,7 @@ struct map_arguments {
LuaRef rhs_lua; /// lua function as {rhs}
bool rhs_is_noop; /// True when the {rhs} should be <Nop>.
char_u *orig_rhs; /// The original text of the {rhs}.
char *orig_rhs; /// The original text of the {rhs}.
size_t orig_rhs_len;
char *desc; /// map description
};

6
src/nvim/mark.c
View File

@ -664,13 +664,13 @@ static void fname2fnum(xfmark_T *fm)
expand_env("~/", NameBuff, MAXPATHL);
int len = (int)strlen(NameBuff);
STRLCPY(NameBuff + len, fm->fname + 2, MAXPATHL - len);
xstrlcpy(NameBuff + len, fm->fname + 2, (size_t)(MAXPATHL - len));
} else {
STRLCPY(NameBuff, fm->fname, MAXPATHL);
xstrlcpy(NameBuff, fm->fname, MAXPATHL);
}
// Try to shorten the file name.
os_dirname((char_u *)IObuff, IOSIZE);
os_dirname(IObuff, IOSIZE);
char *p = path_shorten_fname(NameBuff, IObuff);
// buflist_new() will call fmarks_check_names()

6
src/nvim/memline.c
View File

@ -640,7 +640,7 @@ static void set_b0_fname(ZERO_BL *b0p, buf_T *buf)
size_t ulen = strlen(uname);
size_t flen = strlen(b0p->b0_fname);
if (retval == FAIL || ulen + flen > B0_FNAME_SIZE_CRYPT - 1) {
STRLCPY(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE_CRYPT);
xstrlcpy(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE_CRYPT);
} else {
memmove(b0p->b0_fname + ulen + 1, b0p->b0_fname + 1, flen);
memmove(b0p->b0_fname + 1, uname, ulen);
@ -896,7 +896,7 @@ void ml_recover(bool checkext)
smsg(_("Using swap file \"%s\""), NameBuff);
if (buf_spname(curbuf) != NULL) {
STRLCPY(NameBuff, buf_spname(curbuf), MAXPATHL);
xstrlcpy(NameBuff, buf_spname(curbuf), MAXPATHL);
} else {
home_replace(NULL, curbuf->b_ffname, (char *)NameBuff, MAXPATHL, true);
}
@ -2966,7 +2966,7 @@ int resolve_symlink(const char *fname, char *buf)
}
// Put the result so far in tmp[], starting with the original name.
STRLCPY(tmp, fname, MAXPATHL);
xstrlcpy(tmp, fname, MAXPATHL);
for (;;) {
// Limit symlink depth to 100, catch recursive loops.

6
src/nvim/menu.c
View File

@ -960,7 +960,7 @@ char *set_context_in_menu_cmd(expand_T *xp, const char *cmd, char *arg, bool for
if (after_dot > arg) {
size_t path_len = (size_t)(after_dot - arg);
path_name = xmalloc(path_len);
STRLCPY(path_name, arg, path_len);
xstrlcpy(path_name, arg, path_len);
}
name = path_name;
while (name != NULL && *name) {
@ -1075,9 +1075,9 @@ char *get_menu_names(expand_T *xp, int idx)
if (menu->modes & expand_modes) {
if (menu->children != NULL) {
if (should_advance) {
STRLCPY(tbuffer, menu->en_dname, TBUFFER_LEN);
xstrlcpy(tbuffer, menu->en_dname, TBUFFER_LEN);
} else {
STRLCPY(tbuffer, menu->dname, TBUFFER_LEN);
xstrlcpy(tbuffer, menu->dname, TBUFFER_LEN);
if (menu->en_dname == NULL) {
should_advance = true;
}

6
src/nvim/ops.c
View File

@ -2440,7 +2440,7 @@ int op_change(oparg_T *oap)
long pre_indent = 0;
char_u *newp;
char *firstline;
char_u *ins_text;
char *ins_text;
char *oldp;
struct block_def bd;
@ -2510,8 +2510,8 @@ int op_change(oparg_T *oap)
if (ins_len > 0) {
// Subsequent calls to ml_get() flush the firstline data - take a
// copy of the inserted text.
ins_text = (char_u *)xmalloc((size_t)(ins_len + 1));
STRLCPY(ins_text, firstline + bd.textcol, ins_len + 1);
ins_text = xmalloc((size_t)(ins_len + 1));
xstrlcpy(ins_text, firstline + bd.textcol, (size_t)ins_len + 1);
for (linenr = oap->start.lnum + 1; linenr <= oap->end.lnum;
linenr++) {
block_prep(oap, &bd, linenr, true);

16
src/nvim/option.c
View File

@ -1455,7 +1455,7 @@ skip:
}
if (errmsg != NULL) {
STRLCPY(IObuff, _(errmsg), IOSIZE);
xstrlcpy(IObuff, _(errmsg), IOSIZE);
int i = (int)strlen(IObuff) + 2;
if (i + (arg - startarg) < IOSIZE) {
// append the argument with the error
@ -4798,15 +4798,15 @@ void ExpandOldSetting(int *num_file, char ***file)
/// @param opt_flags OPT_GLOBAL and/or OPT_LOCAL
static void option_value2string(vimoption_T *opp, int scope)
{
char_u *varp = (char_u *)get_varp_scope(opp, scope);
char *varp = get_varp_scope(opp, scope);
if (opp->flags & P_NUM) {
long wc = 0;
if (wc_use_keyname(varp, &wc)) {
STRLCPY(NameBuff, get_special_key_name((int)wc, 0), sizeof(NameBuff));
if (wc_use_keyname((char_u *)varp, &wc)) {
xstrlcpy(NameBuff, (char *)get_special_key_name((int)wc, 0), sizeof(NameBuff));
} else if (wc != 0) {
STRLCPY(NameBuff, transchar((int)wc), sizeof(NameBuff));
xstrlcpy(NameBuff, (char *)transchar((int)wc), sizeof(NameBuff));
} else {
snprintf((char *)NameBuff,
sizeof(NameBuff),
@ -4814,16 +4814,16 @@ static void option_value2string(vimoption_T *opp, int scope)
(int64_t)(*(long *)varp));
}
} else { // P_STRING
varp = *(char_u **)(varp);
varp = *(char **)(varp);
if (varp == NULL) { // Just in case.
NameBuff[0] = NUL;
} else if (opp->flags & P_EXPAND) {
home_replace(NULL, (char *)varp, (char *)NameBuff, MAXPATHL, false);
home_replace(NULL, varp, (char *)NameBuff, MAXPATHL, false);
// Translate 'pastetoggle' into special key names.
} else if ((char **)opp->var == &p_pt) {
str2specialbuf((const char *)p_pt, (char *)NameBuff, MAXPATHL);
} else {
STRLCPY(NameBuff, varp, MAXPATHL);
xstrlcpy(NameBuff, varp, MAXPATHL);
}
}
}

10
src/nvim/os/env.c
View File

@ -488,8 +488,8 @@ void init_homedir(void)
if (var != NULL) {
// Change to the directory and get the actual path. This resolves
// links. Don't do it when we can't return.
if (os_dirname((char_u *)os_buf, MAXPATHL) == OK && os_chdir(os_buf) == 0) {
if (!os_chdir(var) && os_dirname((char_u *)IObuff, IOSIZE) == OK) {
if (os_dirname(os_buf, MAXPATHL) == OK && os_chdir(os_buf) == 0) {
if (!os_chdir(var) && os_dirname(IObuff, IOSIZE) == OK) {
var = (char *)IObuff;
}
if (os_chdir(os_buf) != 0) {
@ -500,7 +500,7 @@ void init_homedir(void)
// Fall back to current working directory if home is not found
if ((var == NULL || *var == NUL)
&& os_dirname((char_u *)os_buf, sizeof(os_buf)) == OK) {
&& os_dirname(os_buf, sizeof(os_buf)) == OK) {
var = os_buf;
}
#endif
@ -1056,7 +1056,7 @@ size_t home_replace(const buf_T *const buf, const char *src, char *const dst, si
}
if (buf != NULL && buf->b_help) {
const size_t dlen = STRLCPY(dst, path_tail((char *)src), dstlen);
const size_t dlen = xstrlcpy(dst, path_tail((char *)src), dstlen);
return MIN(dlen, dstlen - 1);
}
@ -1176,7 +1176,7 @@ char *get_env_name(expand_T *xp, int idx)
assert(idx >= 0);
char *envname = os_getenvname_at_index((size_t)idx);
if (envname) {
STRLCPY(xp->xp_buf, envname, EXPAND_BUF_LEN);
xstrlcpy(xp->xp_buf, envname, EXPAND_BUF_LEN);
xfree(envname);
return xp->xp_buf;
}

8
src/nvim/os/fs.c
View File

@ -105,12 +105,12 @@ int os_chdir(const char *path)
/// @param buf Buffer to store the directory name.
/// @param len Length of `buf`.
/// @return `OK` for success, `FAIL` for failure.
int os_dirname(char_u *buf, size_t len)
int os_dirname(char *buf, size_t len)
FUNC_ATTR_NONNULL_ALL
{
int error_number;
if ((error_number = uv_cwd((char *)buf, &len)) != kLibuvSuccess) {
STRLCPY(buf, uv_strerror(error_number), len);
if ((error_number = uv_cwd(buf, &len)) != kLibuvSuccess) {
xstrlcpy(buf, uv_strerror(error_number), len);
return FAIL;
}
return OK;
@ -379,7 +379,7 @@ static bool is_executable_in_path(const char *name, char **abspath)
char *e = xstrchrnul(p, ENV_SEPCHAR);
// Combine the $PATH segment with `name`.
STRLCPY(buf, p, e - p + 1);
xstrlcpy(buf, p, (size_t)(e - p) + 1);
append_path(buf, name, buf_len);
#ifdef MSWIN

2
src/nvim/os/users.c
View File

@ -146,7 +146,7 @@ int os_get_uname(uv_uid_t uid, char *s, size_t len)
if ((pw = getpwuid(uid)) != NULL // NOLINT(runtime/threadsafe_fn)
&& pw->pw_name != NULL && *(pw->pw_name) != NUL) {
STRLCPY(s, pw->pw_name, len);
xstrlcpy(s, pw->pw_name, len);
return OK;
}
#endif

26
src/nvim/path.c
View File

@ -71,7 +71,7 @@ FileComparison path_full_compare(char *const s1, char *const s2, const bool chec
if (expandenv) {
expand_env(s1, exp1, MAXPATHL);
} else {
STRLCPY(exp1, s1, MAXPATHL);
xstrlcpy(exp1, s1, MAXPATHL);
}
bool id_ok_1 = os_fileid(exp1, &file_id_1);
bool id_ok_2 = os_fileid(s2, &file_id_2);
@ -964,7 +964,7 @@ static void uniquefy_paths(garray_T *gap, char *pattern)
}
char *curdir = xmalloc(MAXPATHL);
os_dirname((char_u *)curdir, MAXPATHL);
os_dirname(curdir, MAXPATHL);
expand_path_option(curdir, &path_ga);
in_curdir = xcalloc((size_t)gap->ga_len, sizeof(char_u *));
@ -1118,7 +1118,7 @@ static int expand_in_path(garray_T *const gap, char_u *const pattern, const int
garray_T path_ga;
char_u *const curdir = xmalloc(MAXPATHL);
os_dirname(curdir, MAXPATHL);
os_dirname((char *)curdir, MAXPATHL);
ga_init(&path_ga, (int)sizeof(char_u *), 1);
expand_path_option((char *)curdir, &path_ga);
@ -1916,12 +1916,12 @@ void path_fix_case(char *name)
// Only accept names that differ in case and are the same byte
// length. TODO: accept different length name.
if (STRICMP(tail, entry) == 0 && strlen(tail) == strlen(entry)) {
char_u newname[MAXPATHL + 1];
char newname[MAXPATHL + 1];
// Verify the inode is equal.
STRLCPY(newname, name, MAXPATHL + 1);
STRLCPY(newname + (tail - name), entry,
MAXPATHL - (tail - name) + 1);
xstrlcpy(newname, name, MAXPATHL + 1);
xstrlcpy(newname + (tail - name), entry,
(size_t)(MAXPATHL - (tail - name) + 1));
FileInfo file_info_new;
if (os_fileinfo_link((char *)newname, &file_info_new)
&& os_fileinfo_id_equal(&file_info, &file_info_new)) {
@ -2049,7 +2049,7 @@ char_u *path_try_shorten_fname(char_u *full_path)
char_u *dirname = xmalloc(MAXPATHL);
char_u *p = full_path;
if (os_dirname(dirname, MAXPATHL) == OK) {
if (os_dirname((char *)dirname, MAXPATHL) == OK) {
p = (char_u *)path_shorten_fname((char *)full_path, (char *)dirname);
if (p == NULL || *p == NUL) {
p = full_path;
@ -2272,13 +2272,13 @@ int path_full_dir_name(char *directory, char *buffer, size_t len)
int retval = OK;
if (strlen(directory) == 0) {
return os_dirname((char_u *)buffer, len);
return os_dirname(buffer, len);
}
char old_dir[MAXPATHL];
// Get current directory name.
if (os_dirname((char_u *)old_dir, MAXPATHL) == FAIL) {
if (os_dirname(old_dir, MAXPATHL) == FAIL) {
return FAIL;
}
@ -2298,7 +2298,7 @@ int path_full_dir_name(char *directory, char *buffer, size_t len)
xstrlcpy(buffer, old_dir, len);
append_path(buffer, directory, len);
}
} else if (os_dirname((char_u *)buffer, len) == FAIL) {
} else if (os_dirname(buffer, len) == FAIL) {
// Do not return immediately since we are in the wrong directory.
retval = FAIL;
}
@ -2421,7 +2421,7 @@ void path_guess_exepath(const char *argv0, char *buf, size_t bufsize)
xstrlcpy(buf, argv0, bufsize);
} else if (argv0[0] == '.' || strchr(argv0, PATHSEP)) {
// Relative to CWD.
if (os_dirname((char_u *)buf, MAXPATHL) != OK) {
if (os_dirname(buf, MAXPATHL) != OK) {
buf[0] = NUL;
}
xstrlcat(buf, PATHSEPSTR, bufsize);
@ -2439,7 +2439,7 @@ void path_guess_exepath(const char *argv0, char *buf, size_t bufsize)
if (dir_len + 1 > sizeof(NameBuff)) {
continue;
}
STRLCPY(NameBuff, dir, dir_len + 1);
xstrlcpy(NameBuff, dir, dir_len + 1);
xstrlcat(NameBuff, PATHSEPSTR, sizeof(NameBuff));
xstrlcat(NameBuff, argv0, sizeof(NameBuff));
if (os_can_exe((char *)NameBuff, NULL, false)) {

28
src/nvim/quickfix.c
View File

@ -712,7 +712,7 @@ static int qf_get_next_list_line(qfstate_T *state)
state->linelen = len;
}
STRLCPY(state->linebuf, TV_LIST_ITEM_TV(p_li)->vval.v_string,
xstrlcpy(state->linebuf, TV_LIST_ITEM_TV(p_li)->vval.v_string,
state->linelen + 1);
state->p_li = TV_LIST_ITEM_NEXT(state->p_list, p_li);
@ -736,7 +736,7 @@ static int qf_get_next_buf_line(qfstate_T *state)
state->linebuf = (char *)IObuff;
state->linelen = len;
}
STRLCPY(state->linebuf, p_buf, state->linelen + 1);
xstrlcpy(state->linebuf, p_buf, state->linelen + 1);
return QF_OK;
}
@ -818,7 +818,7 @@ retry:
char *line = string_convert(&state->vc, state->linebuf, &state->linelen);
if (line != NULL) {
if (state->linelen < IOSIZE) {
STRLCPY(state->linebuf, line, state->linelen + 1);
xstrlcpy(state->linebuf, line, state->linelen + 1);
xfree(line);
} else {
xfree(state->growbuf);
@ -1195,7 +1195,7 @@ static void qf_store_title(qf_list_T *qfl, const char *title)
char *p = xmallocz(len);
qfl->qf_title = p;
STRLCPY(p, title, len + 1);
xstrlcpy(p, title, len + 1);
}
}
@ -1350,7 +1350,7 @@ static int copy_nonerror_line(const char *linebuf, size_t linelen, qffields_T *f
fields->errmsglen = linelen + 1;
}
// copy whole line to error message
STRLCPY(fields->errmsg, linebuf, linelen + 1);
xstrlcpy(fields->errmsg, linebuf, linelen + 1);
return QF_OK;
}
@ -1368,7 +1368,7 @@ static int qf_parse_fmt_m(regmatch_T *rmp, int midx, qffields_T *fields)
fields->errmsg = xrealloc(fields->errmsg, len + 1);
fields->errmsglen = len + 1;
}
STRLCPY(fields->errmsg, rmp->startp[midx], len + 1);
xstrlcpy(fields->errmsg, rmp->startp[midx], len + 1);
return QF_OK;
}
@ -3941,18 +3941,18 @@ static int qf_buf_add_line(qf_list_T *qfl, buf_T *buf, linenr_T lnum, const qfli
// If the 'quickfixtextfunc' function returned a non-empty custom string
// for this entry, then use it.
if (qftf_str != NULL && *qftf_str != NUL) {
STRLCPY(IObuff, qftf_str, IOSIZE);
xstrlcpy(IObuff, qftf_str, IOSIZE);
} else {
buf_T *errbuf;
int len;
if (qfp->qf_module != NULL) {
STRLCPY(IObuff, qfp->qf_module, IOSIZE);
xstrlcpy(IObuff, qfp->qf_module, IOSIZE);
len = (int)strlen(IObuff);
} else if (qfp->qf_fnum != 0
&& (errbuf = buflist_findnr(qfp->qf_fnum)) != NULL
&& errbuf->b_fname != NULL) {
if (qfp->qf_type == 1) { // :helpgrep
STRLCPY(IObuff, path_tail(errbuf->b_fname), IOSIZE);
xstrlcpy(IObuff, path_tail(errbuf->b_fname), IOSIZE);
} else {
// Shorten the file name if not done already.
// For optimization, do this only for the first entry in a
@ -3961,11 +3961,11 @@ static int qf_buf_add_line(qf_list_T *qfl, buf_T *buf, linenr_T lnum, const qfli
&& (errbuf->b_sfname == NULL
|| path_is_absolute((char_u *)errbuf->b_sfname))) {
if (*dirname == NUL) {
os_dirname((char_u *)dirname, MAXPATHL);
os_dirname(dirname, MAXPATHL);
}
shorten_buf_fname(errbuf, (char_u *)dirname, false);
}
STRLCPY(IObuff, errbuf->b_fname, IOSIZE);
xstrlcpy(IObuff, errbuf->b_fname, IOSIZE);
}
len = (int)strlen(IObuff);
} else {
@ -5370,7 +5370,7 @@ static int vgr_process_files(win_T *wp, qf_info_T *qi, vgr_args_T *cmd_args, boo
// Remember the current directory, because a BufRead autocommand that does
// ":lcd %:p:h" changes the meaning of short path names.
os_dirname((char_u *)dirname_start, MAXPATHL);
os_dirname(dirname_start, MAXPATHL);
time_t seconds = (time_t)0;
for (int fi = 0; fi < cmd_args->fcount && !got_int && cmd_args->tomatch > 0; fi++) {
@ -5581,7 +5581,7 @@ static void restore_start_dir(char *dirname_start)
{
char *dirname_now = xmalloc(MAXPATHL);
os_dirname((char_u *)dirname_now, MAXPATHL);
os_dirname(dirname_now, MAXPATHL);
if (strcmp(dirname_start, dirname_now) != 0) {
// If the directory has changed, change it back by building up an
// appropriate ex command and executing it.
@ -5675,7 +5675,7 @@ static buf_T *load_dummy_buffer(char *fname, char *dirname_start, char *resultin
// When autocommands/'autochdir' option changed directory: go back.
// Let the caller know what the resulting dir was first, in case it is
// important.
os_dirname((char_u *)resulting_dir, MAXPATHL);
os_dirname(resulting_dir, MAXPATHL);
restore_start_dir(dirname_start);
if (!bufref_valid(&newbufref)) {

2
src/nvim/regexp.c
View File

@ -2141,7 +2141,7 @@ char *reg_submatch(int no)
// Within one line: take form start to end col.
len = rsm.sm_mmatch->endpos[no].col - rsm.sm_mmatch->startpos[no].col;
if (round == 2) {
STRLCPY(retval, s, len + 1);
xstrlcpy(retval, s, (size_t)len + 1);
}
len++;
} else {

6
src/nvim/runtime.c
View File

@ -654,8 +654,8 @@ static void expand_pack_entry(RuntimeSearchPath *search_path, Map(String, handle
if (pack_entry_len + strlen(start_pat[i]) + 1 > sizeof buf) {
continue;
}
STRLCPY(buf, pack_entry, sizeof buf);
STRLCPY(buf + pack_entry_len, start_pat[i], sizeof buf - pack_entry_len);
xstrlcpy(buf, pack_entry, sizeof buf);
xstrlcpy(buf + pack_entry_len, start_pat[i], sizeof buf - pack_entry_len);
expand_rtp_entry(search_path, rtp_used, buf, false);
size_t after_size = strlen(buf) + 7;
char *after = xmallocz(after_size);
@ -1085,7 +1085,7 @@ static void add_pack_start_dir(char *fname, void *cookie)
if (strlen(fname) + strlen(start_pat[i]) + 1 > MAXPATHL) {
continue;
}
STRLCPY(buf, fname, MAXPATHL);
xstrlcpy(buf, fname, MAXPATHL);
xstrlcat(buf, start_pat[i], sizeof buf);
if (pack_has_entries(buf)) {
add_pack_dir_to_rtp(buf, true);

2
src/nvim/screen.c
View File

@ -681,7 +681,7 @@ static void recording_mode(int attr)
void get_trans_bufname(buf_T *buf)
{
if (buf_spname(buf) != NULL) {
STRLCPY(NameBuff, buf_spname(buf), MAXPATHL);
xstrlcpy(NameBuff, buf_spname(buf), MAXPATHL);
} else {
home_replace(buf, buf->b_fname, (char *)NameBuff, MAXPATHL, true);
}

12
src/nvim/search.c
View File

@ -3414,10 +3414,10 @@ void f_matchfuzzypos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
/// Get line "lnum" and copy it into "buf[LSIZE]".
/// The copy is made because the regexp may make the line invalid when using a
/// mark.
static char_u *get_line_and_copy(linenr_T lnum, char_u *buf)
static char *get_line_and_copy(linenr_T lnum, char *buf)
{
char_u *line = (char_u *)ml_get(lnum);
STRLCPY(buf, line, LSIZE);
char *line = ml_get(lnum);
xstrlcpy(buf, line, LSIZE);
return buf;
}
@ -3517,7 +3517,7 @@ void find_pattern_in_path(char *ptr, Direction dir, size_t len, bool whole, bool
if (lnum > end_lnum) { // do at least one line
lnum = end_lnum;
}
line = (char *)get_line_and_copy(lnum, file_line);
line = get_line_and_copy(lnum, (char *)file_line);
for (;;) {
if (incl_regmatch.regprog != NULL
@ -3794,7 +3794,7 @@ search_line:
if (lnum >= end_lnum) {
goto exit_matched;
}
line = (char *)get_line_and_copy(++lnum, file_line);
line = get_line_and_copy(++lnum, (char *)file_line);
} else if (vim_fgets(line = (char *)file_line,
LSIZE, files[depth].fp)) {
goto exit_matched;
@ -3984,7 +3984,7 @@ exit_matched:
if (++lnum > end_lnum) {
break;
}
line = (char *)get_line_and_copy(lnum, file_line);
line = get_line_and_copy(lnum, (char *)file_line);
}
already = NULL;
}

52
src/nvim/spell.c
View File

@ -739,14 +739,14 @@ static void find_word(matchinf_T *mip, int mode)
mip->mi_compflags[mip->mi_complen] = (char_u)((unsigned)flags >> 24);
mip->mi_compflags[mip->mi_complen + 1] = NUL;
if (word_ends) {
char_u fword[MAXWLEN] = { 0 };
char fword[MAXWLEN] = { 0 };
if (slang->sl_compsylmax < MAXWLEN) {
// "fword" is only needed for checking syllables.
if (ptr == mip->mi_word) {
(void)spell_casefold(mip->mi_win, (char_u *)ptr, wlen, fword, MAXWLEN);
(void)spell_casefold(mip->mi_win, (char_u *)ptr, wlen, (char_u *)fword, MAXWLEN);
} else {
STRLCPY(fword, ptr, endlen[endidxcnt] + 1);
xstrlcpy(fword, ptr, (size_t)endlen[endidxcnt] + 1);
}
}
if (!can_compound(slang, (char *)fword, mip->mi_compflags)) {
@ -1318,7 +1318,7 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
bool empty_line = *skipwhite((const char *)line) == NUL;
STRCPY(buf, line);
if (lnum < wp->w_buffer->b_ml.ml_line_count) {
spell_cat_line((char_u *)buf + strlen(buf),
spell_cat_line(buf + strlen(buf),
(char_u *)ml_get_buf(wp->w_buffer, lnum + 1, false),
MAXWLEN);
}
@ -1480,7 +1480,7 @@ theend:
// "buf", blanking-out special characters. Copy less than "maxlen" bytes.
// Keep the blanks at the start of the next line, this is used in win_line()
// to skip those bytes if the word was OK.
void spell_cat_line(char_u *buf, char_u *line, int maxlen)
void spell_cat_line(char *buf, char_u *line, int maxlen)
{
char_u *p = (char_u *)skipwhite((char *)line);
while (vim_strchr("*#/\"\t", *p) != NULL) {
@ -1493,7 +1493,7 @@ void spell_cat_line(char_u *buf, char_u *line, int maxlen)
int n = (int)(p - line) + 1;
if (n < maxlen - 1) {
memset(buf, ' ', (size_t)n);
STRLCPY(buf + n, p, maxlen - n);
xstrlcpy(buf + n, (char *)p, (size_t)(maxlen - n));
}
}
}
@ -1731,7 +1731,7 @@ void count_common_word(slang_T *lp, char *word, int len, uint8_t count)
} else if (len >= MAXWLEN) {
return;
} else {
STRLCPY(buf, word, len + 1);
xstrlcpy(buf, word, (size_t)len + 1);
p = buf;
}
@ -1789,7 +1789,7 @@ int init_syl_tab(slang_T *slang)
}
syl_item_T *syl = GA_APPEND_VIA_PTR(syl_item_T, &slang->sl_syl_items);
STRLCPY(syl->sy_chars, s, l + 1);
xstrlcpy(syl->sy_chars, s, (size_t)l + 1);
syl->sy_len = l;
}
return OK;
@ -1916,7 +1916,7 @@ char *did_set_spelllang(win_T *wp)
p = vim_strchr(path_tail((char *)lang), '_');
if (p != NULL && ASCII_ISALPHA(p[1]) && ASCII_ISALPHA(p[2])
&& !ASCII_ISALPHA(p[3])) {
STRLCPY(region_cp, p + 1, 3);
xstrlcpy(region_cp, p + 1, 3);
memmove(p, p + 3, (size_t)(len - (p - lang) - 2));
region = region_cp;
} else {
@ -2055,7 +2055,7 @@ char *did_set_spelllang(win_T *wp)
if (round == 0) {
STRCPY(lang, "internal wordlist");
} else {
STRLCPY(lang, path_tail((char *)spf_name), MAXWLEN + 1);
xstrlcpy(lang, path_tail((char *)spf_name), MAXWLEN + 1);
p = vim_strchr((char *)lang, '.');
if (p != NULL) {
*p = NUL; // truncate at ".encoding.add"
@ -2176,7 +2176,7 @@ static void use_midword(slang_T *lp, win_T *wp)
char *bp = xstrnsave(wp->w_s->b_spell_ismw_mb, (size_t)n + (size_t)l);
xfree(wp->w_s->b_spell_ismw_mb);
wp->w_s->b_spell_ismw_mb = bp;
STRLCPY(bp + n, p, l + 1);
xstrlcpy(bp + n, p, (size_t)l + 1);
}
p += l;
}
@ -2634,7 +2634,7 @@ void ex_spellrepall(exarg_T *eap)
/// @param[in] word source string to copy
/// @param[in,out] wcopy copied string, with case of first letter changed
/// @param[in] upper True to upper case, otherwise lower case
void onecap_copy(char_u *word, char_u *wcopy, bool upper)
void onecap_copy(char_u *word, char *wcopy, bool upper)
{
char_u *p = word;
int c = mb_cptr2char_adv((const char_u **)&p);
@ -2643,8 +2643,8 @@ void onecap_copy(char_u *word, char_u *wcopy, bool upper)
} else {
c = SPELL_TOFOLD(c);
}
int l = utf_char2bytes(c, (char *)wcopy);
STRLCPY(wcopy + l, p, MAXWLEN - l);
int l = utf_char2bytes(c, wcopy);
xstrlcpy(wcopy + l, (char *)p, (size_t)(MAXWLEN - l));
}
// Make a copy of "word" with all the letters upper cased into
@ -2697,7 +2697,7 @@ void make_case_word(char_u *fword, char_u *cword, int flags)
allcap_copy(fword, cword);
} else if (flags & WF_ONECAP) {
// Make the first letter upper-case
onecap_copy(fword, cword, true);
onecap_copy(fword, (char *)cword, true);
} else {
// Use goodword as-is.
STRCPY(cword, fword);
@ -3319,7 +3319,7 @@ void spell_dump_compl(char *pat, int ic, Direction *dir, int dumpflags_arg)
// Apply the prefix, if there is one.
if (c != 0) {
lnum = dump_prefixes(slang, (char_u *)word, (char_u *)pat, dir,
lnum = dump_prefixes(slang, word, (char_u *)pat, dir,
dumpflags, flags, lnum);
}
}
@ -3436,21 +3436,21 @@ static void dump_word(slang_T *slang, char *word, char *pat, Direction *dir, int
/// @param flags flags with prefix ID
///
/// @return the updated line number.
static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Direction *dir,
static linenr_T dump_prefixes(slang_T *slang, char *word, char_u *pat, Direction *dir,
int dumpflags, int flags, linenr_T startlnum)
{
idx_T arridx[MAXWLEN];
int curi[MAXWLEN];
char_u prefix[MAXWLEN];
char_u word_up[MAXWLEN];
char prefix[MAXWLEN];
char word_up[MAXWLEN];
bool has_word_up = false;
linenr_T lnum = startlnum;
// If the word starts with a lower-case letter make the word with an
// upper-case letter in word_up[].
int c = utf_ptr2char((char *)word);
int c = utf_ptr2char(word);
if (SPELL_TOUPPER(c) != c) {
onecap_copy(word, word_up, true);
onecap_copy((char_u *)word, (char *)word_up, true);
has_word_up = true;
}
@ -3484,9 +3484,9 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
}
curi[depth] += i - 1;
c = valid_word_prefix(i, n, flags, word, slang, false);
c = valid_word_prefix(i, n, flags, (char_u *)word, slang, false);
if (c != 0) {
STRLCPY(prefix + depth, word, MAXWLEN - depth);
xstrlcpy(prefix + depth, word, (size_t)(MAXWLEN - depth));
dump_word(slang, (char *)prefix, (char *)pat, dir, dumpflags,
(c & WF_RAREPFX) ? (flags | WF_RARE) : flags, lnum);
if (lnum != 0) {
@ -3498,10 +3498,10 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
// first letter is upper-case, but only if the prefix has
// a condition.
if (has_word_up) {
c = valid_word_prefix(i, n, flags, word_up, slang,
c = valid_word_prefix(i, n, flags, (char_u *)word_up, slang,
true);
if (c != 0) {
STRLCPY(prefix + depth, word_up, MAXWLEN - depth);
xstrlcpy(prefix + depth, word_up, (size_t)(MAXWLEN - depth));
dump_word(slang, (char *)prefix, (char *)pat, dir, dumpflags,
(c & WF_RAREPFX) ? (flags | WF_RARE) : flags, lnum);
if (lnum != 0) {
@ -3511,7 +3511,7 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
}
} else {
// Normal char, go one level deeper.
prefix[depth++] = (char_u)c;
prefix[depth++] = (char)c;
arridx[depth] = idxs[n];
curi[depth] = 1;
}

60
src/nvim/spellfile.c
View File

@ -2348,7 +2348,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
&& aff_todo == 0
&& itemcnt >= 4) {
int lasti = 4;
char_u key[AH_KEY_LEN];
char key[AH_KEY_LEN];
if (*items[0] == 'P') {
tp = &aff->af_pref;
@ -2360,7 +2360,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
// times. The affix files that do this have an undocumented
// "S" flag on all but the last block, thus we check for that
// and store it in ah_follows.
STRLCPY(key, items[1], AH_KEY_LEN);
xstrlcpy(key, items[1], AH_KEY_LEN);
hi = hash_find(tp, (char *)key);
if (!HASHITEM_EMPTY(hi)) {
cur_aff = HI2AH(hi);
@ -2533,7 +2533,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
// upper-case letter.
if (aff_entry->ae_cond != NULL) {
char_u buf[MAXLINELEN];
onecap_copy((char_u *)items[4], buf, true);
onecap_copy((char_u *)items[4], (char *)buf, true);
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)
@ -2902,13 +2902,13 @@ static unsigned get_affitem(int flagtype, char_u **pp)
static void process_compflags(spellinfo_T *spin, afffile_T *aff, char *compflags)
{
char *p;
char_u *prevp;
char *prevp;
unsigned flag;
compitem_T *ci;
int id;
int len;
char_u *tp;
char_u key[AH_KEY_LEN];
char key[AH_KEY_LEN];
hashitem_T *hi;
// Make room for the old and the new compflags, concatenated with a / in
@ -2932,12 +2932,12 @@ static void process_compflags(spellinfo_T *spin, afffile_T *aff, char *compflags
*tp++ = (char_u)(*p++);
} else {
// First get the flag number, also checks validity.
prevp = (char_u *)p;
prevp = 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, (char_u *)p - prevp + 1);
xstrlcpy(key, prevp, (size_t)(p - prevp) + 1);
hi = hash_find(&aff->af_comp, (char *)key);
if (!HASHITEM_EMPTY(hi)) {
id = HI2CI(hi)->ci_newID;
@ -3281,14 +3281,14 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
// Additionally do matching prefixes that combine.
if (store_aff_word(spin, dw, afflist, affile,
&affile->af_suff, &affile->af_pref,
CONDIT_SUF, flags, store_afflist, pfxlen) == FAIL) {
CONDIT_SUF, flags, (char *)store_afflist, pfxlen) == FAIL) {
retval = FAIL;
}
// Find all matching prefixes and add the resulting words.
if (store_aff_word(spin, dw, afflist, affile,
&affile->af_pref, NULL,
CONDIT_SUF, flags, store_afflist, pfxlen) == FAIL) {
CONDIT_SUF, flags, (char *)store_afflist, pfxlen) == FAIL) {
retval = FAIL;
}
}
@ -3353,18 +3353,18 @@ static int get_affix_flags(afffile_T *affile, char_u *afflist)
static int get_pfxlist(afffile_T *affile, char_u *afflist, char_u *store_afflist)
{
char_u *p;
char_u *prevp;
char *prevp;
int cnt = 0;
int id;
char_u key[AH_KEY_LEN];
char key[AH_KEY_LEN];
hashitem_T *hi;
for (p = afflist; *p != NUL;) {
prevp = p;
prevp = (char *)p;
if (get_affitem(affile->af_flagtype, &p) != 0) {
// A flag is a postponed prefix flag if it appears in "af_pref"
// and its ID is not zero.
STRLCPY(key, prevp, p - prevp + 1);
xstrlcpy(key, prevp, (size_t)(p - (char_u *)prevp) + 1);
hi = hash_find(&affile->af_pref, (char *)key);
if (!HASHITEM_EMPTY(hi)) {
id = HI2AH(hi)->ah_newID;
@ -3388,16 +3388,16 @@ static int get_pfxlist(afffile_T *affile, char_u *afflist, char_u *store_afflist
static void get_compflags(afffile_T *affile, char_u *afflist, char_u *store_afflist)
{
char_u *p;
char_u *prevp;
char *prevp;
int cnt = 0;
char_u key[AH_KEY_LEN];
char key[AH_KEY_LEN];
hashitem_T *hi;
for (p = afflist; *p != NUL;) {
prevp = p;
prevp = (char *)p;
if (get_affitem(affile->af_flagtype, &p) != 0) {
// A flag is a compound flag if it appears in "af_comp".
STRLCPY(key, prevp, p - prevp + 1);
xstrlcpy(key, prevp, (size_t)(p - (char_u *)prevp) + 1);
hi = hash_find(&affile->af_comp, (char *)key);
if (!HASHITEM_EMPTY(hi)) {
store_afflist[cnt++] = (char_u)HI2CI(hi)->ci_newID;
@ -3427,7 +3427,7 @@ static void get_compflags(afffile_T *affile, char_u *afflist, char_u *store_affl
///
/// @return FAIL when out of memory.
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,
hashtab_T *ht, hashtab_T *xht, int condit, int flags, char *pfxlist,
int pfxlen)
{
int todo;
@ -3439,11 +3439,11 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
int i, j;
char_u *p;
int use_flags;
char_u *use_pfxlist;
char *use_pfxlist;
int use_pfxlen;
bool need_affix;
char_u store_afflist[MAXWLEN];
char_u pfx_pfxlist[MAXWLEN];
char pfx_pfxlist[MAXWLEN];
size_t wordlen = strlen(word);
int use_condit;
@ -3488,7 +3488,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
if (ae->ae_add == NULL) {
*newword = NUL;
} else {
STRLCPY(newword, ae->ae_add, MAXWLEN);
xstrlcpy(newword, ae->ae_add, MAXWLEN);
}
p = (char_u *)word;
if (ae->ae_chop != NULL) {
@ -3501,7 +3501,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
STRCAT(newword, p);
} else {
// suffix: chop/add at the end of the word
STRLCPY(newword, word, MAXWLEN);
xstrlcpy(newword, word, MAXWLEN);
if (ae->ae_chop != NULL) {
// Remove chop string.
p = (char_u *)newword + strlen(newword);
@ -3550,7 +3550,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
} else {
use_pfxlen = 0;
}
use_pfxlist = store_afflist;
use_pfxlist = (char *)store_afflist;
// Combine the prefix IDs. Avoid adding the
// same ID twice.
@ -3568,7 +3568,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
if (spin->si_compflags != NULL) {
// Get compound IDS from the affix list.
get_compflags(affile, ae->ae_flags,
use_pfxlist + use_pfxlen);
(char_u *)use_pfxlist + use_pfxlen);
} else {
use_pfxlist[use_pfxlen] = NUL;
}
@ -3593,7 +3593,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
// Obey a "COMPOUNDFORBIDFLAG" of the affix: don't
// use the compound flags.
if (use_pfxlist != NULL && ae->ae_compforbid) {
STRLCPY(pfx_pfxlist, use_pfxlist, use_pfxlen + 1);
xstrlcpy(pfx_pfxlist, use_pfxlist, (size_t)use_pfxlen + 1);
use_pfxlist = pfx_pfxlist;
}
@ -3624,7 +3624,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char_u *afflist, afffil
// Store the modified word.
if (store_word(spin, newword, use_flags,
spin->si_region, use_pfxlist,
spin->si_region, (char_u *)use_pfxlist,
need_affix) == FAIL) {
retval = FAIL;
}
@ -4970,7 +4970,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
// Write the .sug file.
// Make the file name by changing ".spl" to ".sug".
fname = xmalloc(MAXPATHL);
STRLCPY(fname, wfname, MAXPATHL);
xstrlcpy(fname, wfname, MAXPATHL);
len = (int)strlen(fname);
fname[len - 2] = 'u';
fname[len - 1] = 'g';
@ -5328,7 +5328,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
fnames[0], spin.si_ascii ? (char_u *)"ascii" : spell_enc());
} else if (len > 4 && strcmp(fnames[0] + len - 4, ".spl") == 0) {
// Name ends in ".spl", use as the file name.
STRLCPY(wfname, fnames[0], MAXPATHL);
xstrlcpy(wfname, fnames[0], MAXPATHL);
} else {
// Name should be language, make the file name from it.
vim_snprintf(wfname, MAXPATHL, SPL_FNAME_TMPL,
@ -5716,7 +5716,7 @@ static void init_spellfile(void)
if (aspath) {
// Use directory of an entry with path, e.g., for
// "/dir/lg.utf-8.spl" use "/dir".
STRLCPY(buf, curbuf->b_s.b_p_spl, lstart - (char_u *)curbuf->b_s.b_p_spl);
xstrlcpy(buf, curbuf->b_s.b_p_spl, (size_t)(lstart - (char_u *)curbuf->b_s.b_p_spl));
} else {
// Copy the path from 'runtimepath' to buf[].
copy_option_part((char **)&rtp, buf, MAXPATHL, ",");
@ -5725,7 +5725,7 @@ static void init_spellfile(void)
// 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);
xstrlcpy(buf, curbuf->b_s.b_p_spl, (size_t)(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);

38
src/nvim/spellsuggest.c
View File

@ -445,7 +445,7 @@ void spell_suggest(int count)
{
char *line;
pos_T prev_cursor = curwin->w_cursor;
char_u wcopy[MAXWLEN + 2];
char wcopy[MAXWLEN + 2];
char_u *p;
int c;
suginfo_T sug;
@ -562,10 +562,10 @@ void spell_suggest(int count)
// The suggested word may replace only part of the bad word, add
// the not replaced part. But only when it's not getting too long.
STRLCPY(wcopy, stp->st_word, MAXWLEN + 1);
xstrlcpy(wcopy, stp->st_word, MAXWLEN + 1);
int el = sug.su_badlen - stp->st_orglen;
if (el > 0 && stp->st_wordlen + el <= MAXWLEN) {
STRLCPY(wcopy + stp->st_wordlen, sug.su_badptr + stp->st_orglen, el + 1);
xstrlcpy(wcopy + stp->st_wordlen, sug.su_badptr + stp->st_orglen, (size_t)el + 1);
}
vim_snprintf((char *)IObuff, IOSIZE, "%2d", i + 1);
if (cmdmsg_rl) {
@ -743,7 +743,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
if (su->su_badlen >= MAXWLEN) {
su->su_badlen = MAXWLEN - 1; // just in case
}
STRLCPY(su->su_badword, su->su_badptr, su->su_badlen + 1);
xstrlcpy((char *)su->su_badword, su->su_badptr, (size_t)su->su_badlen + 1);
(void)spell_casefold(curwin, (char_u *)su->su_badptr, su->su_badlen, (char_u *)su->su_fbadword,
MAXWLEN);
@ -783,7 +783,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
// for that.
c = utf_ptr2char(su->su_badptr);
if (!SPELL_ISUPPER(c) && attr == HLF_COUNT) {
make_case_word(su->su_badword, (char_u *)buf, WF_ONECAP);
make_case_word((char_u *)su->su_badword, (char_u *)buf, WF_ONECAP);
add_suggestion(su, &su->su_ga, (char *)buf, su->su_badlen, SCORE_ICASE,
0, true, su->su_sallang, false);
}
@ -1393,9 +1393,9 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char *fword, bool soun
compflags[sp->ts_complen] = (char_u)((unsigned)flags >> 24);
compflags[sp->ts_complen + 1] = NUL;
STRLCPY(preword + sp->ts_prewordlen,
xstrlcpy(preword + sp->ts_prewordlen,
tword + sp->ts_splitoff,
sp->ts_twordlen - sp->ts_splitoff + 1);
(size_t)(sp->ts_twordlen - sp->ts_splitoff) + 1);
// Verify CHECKCOMPOUNDPATTERN rules.
if (match_checkcompoundpattern(preword, sp->ts_prewordlen,
@ -2584,7 +2584,7 @@ static void score_combine(suginfo_T *su)
// Add the alternate score to su_sga.
for (int i = 0; i < su->su_sga.ga_len; i++) {
stp = &SUG(su->su_sga, i);
stp->st_altscore = spell_edit_score(slang, su->su_badword, (char_u *)stp->st_word);
stp->st_altscore = spell_edit_score(slang, (char_u *)su->su_badword, (char_u *)stp->st_word);
if (stp->st_score == SCORE_MAXMAX) {
stp->st_score = (SCORE_BIG * 7 + stp->st_altscore) / 8;
} else {
@ -2653,7 +2653,7 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
char_u badsound2[MAXWLEN];
char_u fword[MAXWLEN];
char_u goodsound[MAXWLEN];
char_u goodword[MAXWLEN];
char goodword[MAXWLEN];
int lendiff;
lendiff = su->su_badlen - stp->st_orglen;
@ -2682,9 +2682,9 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
// Add part of the bad word to the good word, so that we soundfold
// what replaces the bad word.
STRCPY(goodword, stp->st_word);
STRLCPY(goodword + stp->st_wordlen,
su->su_badptr + su->su_badlen - lendiff, lendiff + 1);
pgood = goodword;
xstrlcpy(goodword + stp->st_wordlen,
su->su_badptr + su->su_badlen - lendiff, (size_t)lendiff + 1);
pgood = (char_u *)goodword;
} else {
pgood = (char_u *)stp->st_word;
}
@ -2949,9 +2949,9 @@ badword:
// inefficient, using an array is quicker.
limit = MAXSCORE(su->su_sfmaxscore - goodscore, score);
if (limit > SCORE_LIMITMAX) {
goodscore += spell_edit_score(slang, su->su_badword, p);
goodscore += spell_edit_score(slang, (char_u *)su->su_badword, p);
} else {
goodscore += spell_edit_score_limit(slang, su->su_badword,
goodscore += spell_edit_score_limit(slang, (char_u *)su->su_badword,
p, limit);
}
@ -3205,7 +3205,7 @@ static void add_suggestion(suginfo_T *su, garray_T *gap, const char *goodword, i
static void check_suggestions(suginfo_T *su, garray_T *gap)
{
suggest_T *stp;
char_u longword[MAXWLEN + 1];
char longword[MAXWLEN + 1];
int len;
hlf_T attr;
@ -3215,12 +3215,12 @@ static void check_suggestions(suginfo_T *su, garray_T *gap)
stp = &SUG(*gap, 0);
for (int i = gap->ga_len - 1; i >= 0; i--) {
// Need to append what follows to check for "the the".
STRLCPY(longword, stp[i].st_word, MAXWLEN + 1);
xstrlcpy(longword, stp[i].st_word, MAXWLEN + 1);
len = stp[i].st_wordlen;
STRLCPY(longword + len, su->su_badptr + stp[i].st_orglen,
MAXWLEN - len + 1);
xstrlcpy(longword + len, su->su_badptr + stp[i].st_orglen,
(size_t)(MAXWLEN - len + 1));
attr = HLF_COUNT;
(void)spell_check(curwin, longword, &attr, NULL, false);
(void)spell_check(curwin, (char_u *)longword, &attr, NULL, false);
if (attr != HLF_COUNT) {
// Remove this entry.
xfree(stp[i].st_word);

4
src/nvim/statusline.c
View File

@ -374,7 +374,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
// Make all characters printable.
p = transstr(buf, true);
len = (int)STRLCPY(buf, p, sizeof(buf));
len = (int)xstrlcpy(buf, p, sizeof(buf));
len = (size_t)len < sizeof(buf) ? len : (int)sizeof(buf) - 1;
xfree(p);
@ -1349,7 +1349,7 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
// get replaced with the fillchar
fillable = false;
if (buf_spname(wp->w_buffer) != NULL) {
STRLCPY(NameBuff, buf_spname(wp->w_buffer), MAXPATHL);
xstrlcpy(NameBuff, buf_spname(wp->w_buffer), MAXPATHL);
} else {
char *t = (opt == STL_FULLPATH) ? wp->w_buffer->b_ffname
: wp->w_buffer->b_fname;

12
src/nvim/syntax.c
View File

@ -2742,20 +2742,20 @@ static int check_keyword_id(char *const line, const int startcol, int *const end
// Must make a copy of the keyword, so we can add a NUL and make it
// lowercase.
char_u keyword[MAXKEYWLEN + 1]; // assume max. keyword len is 80
STRLCPY(keyword, kwp, kwlen + 1);
char keyword[MAXKEYWLEN + 1]; // assume max. keyword len is 80
xstrlcpy(keyword, kwp, (size_t)kwlen + 1);
keyentry_T *kp = NULL;
// matching case
if (syn_block->b_keywtab.ht_used != 0) {
kp = match_keyword((char *)keyword, &syn_block->b_keywtab, cur_si);
kp = match_keyword(keyword, &syn_block->b_keywtab, cur_si);
}
// ignoring case
if (kp == NULL && syn_block->b_keywtab_ic.ht_used != 0) {
str_foldcase((char_u *)kwp, kwlen, (char *)keyword, MAXKEYWLEN + 1);
kp = match_keyword((char *)keyword, &syn_block->b_keywtab_ic, cur_si);
str_foldcase((char_u *)kwp, kwlen, keyword, MAXKEYWLEN + 1);
kp = match_keyword(keyword, &syn_block->b_keywtab_ic, cur_si);
}
if (kp != NULL) {
@ -4989,7 +4989,7 @@ static int get_id_list(char **const arg, const int keylen, int16_t **const list,
do {
for (end = p; *end && !ascii_iswhite(*end) && *end != ','; end++) {}
char *const name = xmalloc((size_t)(end - p) + 3); // leave room for "^$"
STRLCPY(name + 1, p, end - p + 1);
xstrlcpy(name + 1, p, (size_t)(end - p) + 1);
if (strcmp(name + 1, "ALLBUT") == 0
|| strcmp(name + 1, "ALL") == 0
|| strcmp(name + 1, "TOP") == 0

36
src/nvim/tag.c
View File

@ -984,11 +984,11 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
static int add_llist_tags(char_u *tag, int num_matches, char **matches)
{
list_T *list;
char_u tag_name[128 + 1];
char_u *fname;
char tag_name[128 + 1];
char *fname;
char_u *cmd;
int i;
char_u *p;
char *p;
tagptrs_T tagp;
fname = xmalloc(MAXPATHL + 1);
@ -1007,15 +1007,15 @@ static int add_llist_tags(char_u *tag, int num_matches, char **matches)
if (len > 128) {
len = 128;
}
STRLCPY(tag_name, tagp.tagname, len + 1);
xstrlcpy(tag_name, tagp.tagname, (size_t)len + 1);
tag_name[len] = NUL;
// Save the tag file name
p = tag_full_fname(&tagp);
p = (char *)tag_full_fname(&tagp);
if (p == NULL) {
continue;
}
STRLCPY(fname, p, MAXPATHL);
xstrlcpy(fname, p, MAXPATHL);
XFREE_CLEAR(p);
// Get the line number or the search pattern used to locate
@ -1033,9 +1033,9 @@ static int add_llist_tags(char_u *tag, int num_matches, char **matches)
cmd_start = (char_u *)tagp.command;
cmd_end = tagp.command_end;
if (cmd_end == NULL) {
for (p = (char_u *)tagp.command;
for (p = tagp.command;
*p && *p != '\r' && *p != '\n'; p++) {}
cmd_end = p;
cmd_end = (char_u *)p;
}
// Now, cmd_end points to the character after the
@ -1091,7 +1091,7 @@ static int add_llist_tags(char_u *tag, int num_matches, char **matches)
dict = tv_dict_alloc();
tv_list_append_dict(list, dict);
tv_dict_add_str(dict, S_LEN("text"), (const char *)tag_name);
tv_dict_add_str(dict, S_LEN("text"), tag_name);
tv_dict_add_str(dict, S_LEN("filename"), (const char *)fname);
tv_dict_add_nr(dict, S_LEN("lnum"), lnum);
if (lnum == 0) {
@ -1484,7 +1484,7 @@ static bool findtags_in_help_init(findtags_state_T *st)
// language name in help_lang[].
i = (int)strlen(st->tag_fname);
if (i > 3 && st->tag_fname[i - 3] == '-') {
STRLCPY(st->help_lang, st->tag_fname + i - 2, 3);
xstrlcpy(st->help_lang, st->tag_fname + i - 2, 3);
} else {
STRCPY(st->help_lang, "en");
}
@ -2034,7 +2034,7 @@ static void findtags_add_match(findtags_state_T *st, tagptrs_T *tagpp, findtags_
if (tagpp->command + 2 < (char *)temp_end) {
len = (size_t)(temp_end - (char_u *)tagpp->command - 2);
mfp = xmalloc(len + 2);
STRLCPY(mfp, tagpp->command + 2, len + 1);
xstrlcpy(mfp, tagpp->command + 2, len + 1);
} else {
mfp = NULL;
}
@ -2042,7 +2042,7 @@ static void findtags_add_match(findtags_state_T *st, tagptrs_T *tagpp, findtags_
} else {
len = (size_t)((char *)tagpp->tagname_end - tagpp->tagname);
mfp = xmalloc(sizeof(char) + len + 1);
STRLCPY(mfp, tagpp->tagname, len + 1);
xstrlcpy(mfp, tagpp->tagname, len + 1);
// if wanted, re-read line to get long form too
if (State & MODE_INSERT) {
@ -2558,7 +2558,7 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
}
}
} else {
STRLCPY(buf, ((char **)(tag_fnames.ga_data))[tnp->tn_hf_idx++], MAXPATHL);
xstrlcpy(buf, ((char **)(tag_fnames.ga_data))[tnp->tn_hf_idx++], MAXPATHL);
}
return OK;
}
@ -3140,8 +3140,7 @@ static char *expand_tag_fname(char *fname, char *const tag_fname, const bool exp
&& (p = path_tail(tag_fname)) != tag_fname) {
retval = xmalloc(MAXPATHL);
STRCPY(retval, tag_fname);
STRLCPY(retval + (p - tag_fname), fname,
MAXPATHL - (p - tag_fname));
xstrlcpy(retval + (p - tag_fname), fname, (size_t)(MAXPATHL - (p - tag_fname)));
// Translate names like "src/a/../b/file.c" into "src/b/file.c".
simplify_filename((char_u *)retval);
} else {
@ -3303,7 +3302,7 @@ static int add_tag_field(dict_T *dict, const char *field_name, const char *start
}
return FAIL;
}
char_u *buf = xmalloc(MAXPATHL);
char *buf = xmalloc(MAXPATHL);
if (start != NULL) {
if (end == NULL) {
end = start + strlen(start);
@ -3315,11 +3314,10 @@ static int add_tag_field(dict_T *dict, const char *field_name, const char *start
if (len > MAXPATHL - 1) {
len = MAXPATHL - 1;
}
STRLCPY(buf, start, len + 1);
xstrlcpy(buf, start, (size_t)len + 1);
}
buf[len] = NUL;
retval = tv_dict_add_str(dict, field_name, strlen(field_name),
(const char *)buf);
retval = tv_dict_add_str(dict, field_name, strlen(field_name), buf);
xfree(buf);
return retval;
}

2
src/nvim/ui_compositor.c
View File

@ -569,7 +569,7 @@ void ui_comp_msg_set_pos(Integer grid, Integer row, Boolean scrolled, String sep
if (scrolled && row > 0) {
msg_sep_row = (int)row - 1;
if (sep_char.data) {
STRLCPY(msg_sep_char, sep_char.data, sizeof(msg_sep_char));
xstrlcpy(msg_sep_char, sep_char.data, sizeof(msg_sep_char));
}
} else {
msg_sep_row = -1;

1
src/nvim/vim.h
View File

@ -200,7 +200,6 @@ enum { FOLD_TEXT_LEN = 51, }; //!< buffer size for get_foldtext()
#endif
#define STRCPY(d, s) strcpy((char *)(d), (char *)(s)) // NOLINT(runtime/printf)
#define STRLCPY(d, s, n) xstrlcpy((char *)(d), (char *)(s), (size_t)(n))
#ifdef HAVE_STRCASECMP
# define STRICMP(d, s) strcasecmp((char *)(d), (char *)(s))
#else

4
src/nvim/window.c
View File

@ -648,7 +648,7 @@ wingotofile:
static void cmd_with_count(char *cmd, char *bufp, size_t bufsize, int64_t Prenum)
{
size_t len = STRLCPY(bufp, cmd, bufsize);
size_t len = xstrlcpy(bufp, cmd, bufsize);
if (Prenum > 0 && len < bufsize) {
vim_snprintf(bufp + len, bufsize - len, "%" PRId64, Prenum);
@ -4879,7 +4879,7 @@ void fix_current_dir(void)
// New directory is either the local directory of the window, tab or NULL.
char *new_dir = curwin->w_localdir ? curwin->w_localdir : curtab->tp_localdir;
char cwd[MAXPATHL];
if (os_dirname((char_u *)cwd, MAXPATHL) != OK) {
if (os_dirname(cwd, MAXPATHL) != OK) {
cwd[0] = NUL;
}