IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

*: Make set_vim_var_\* functions have proper argument types

Browse Source
This commit is contained in:
ZyX 2016-03-20 21:31:49 +03:00
parent 9af400f979
commit 494b1c9bee
23 changed files with 381 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
src/nvim/diff.c
View File

@ -658,9 +658,9 @@ void ex_diffupdate(exarg_T *eap)
}
// We need three temp file names.
char_u *tmp_orig = vim_tempname();
char_u *tmp_new = vim_tempname();
char_u *tmp_diff = vim_tempname();
char *tmp_orig = (char *) vim_tempname();
char *tmp_new = (char *) vim_tempname();
char *tmp_diff = (char *) vim_tempname();
if ((tmp_orig == NULL) || (tmp_new == NULL) || (tmp_diff == NULL)) {
goto theend;
@ -670,11 +670,11 @@ void ex_diffupdate(exarg_T *eap)
// are no differences. Can't use the return value, it's non-zero when
// there are differences.
// May try twice, first with "-a" and then without.
int io_error = FALSE;
int ok = FALSE;
int io_error = false;
bool ok = false;
for (;;) {
ok = FALSE;
FILE *fd = mch_fopen((char *)tmp_orig, "w");
ok = false;
FILE *fd = mch_fopen(tmp_orig, "w");
if (fd == NULL) {
io_error = TRUE;
@ -683,7 +683,7 @@ void ex_diffupdate(exarg_T *eap)
io_error = TRUE;
}
fclose(fd);
fd = mch_fopen((char *)tmp_new, "w");
fd = mch_fopen(tmp_new, "w");
if (fd == NULL) {
io_error = TRUE;
@ -693,7 +693,7 @@ void ex_diffupdate(exarg_T *eap)
}
fclose(fd);
diff_file(tmp_orig, tmp_new, tmp_diff);
fd = mch_fopen((char *)tmp_diff, "r");
fd = mch_fopen(tmp_diff, "r");
if (fd == NULL) {
io_error = TRUE;
@ -712,10 +712,10 @@ void ex_diffupdate(exarg_T *eap)
}
fclose(fd);
}
os_remove((char *)tmp_diff);
os_remove((char *)tmp_new);
os_remove(tmp_diff);
os_remove(tmp_new);
}
os_remove((char *)tmp_orig);
os_remove(tmp_orig);
}
// When using 'diffexpr' break here.
@ -756,7 +756,7 @@ void ex_diffupdate(exarg_T *eap)
// Write the first buffer to a tempfile.
buf_T *buf = curtab->tp_diffbuf[idx_orig];
if (diff_write(buf, tmp_orig) == FAIL) {
if (diff_write(buf, (char_u *) tmp_orig) == FAIL) {
goto theend;
}
@ -767,17 +767,17 @@ void ex_diffupdate(exarg_T *eap)
continue; // skip buffer that isn't loaded
}
if (diff_write(buf, tmp_new) == FAIL) {
if (diff_write(buf, (char_u *) tmp_new) == FAIL) {
continue;
}
diff_file(tmp_orig, tmp_new, tmp_diff);
// Read the diff output and add each entry to the diff list.
diff_read(idx_orig, idx_new, tmp_diff);
os_remove((char *)tmp_diff);
os_remove((char *)tmp_new);
diff_read(idx_orig, idx_new, (char_u *) tmp_diff);
os_remove(tmp_diff);
os_remove(tmp_new);
}
os_remove((char *)tmp_orig);
os_remove(tmp_orig);
// force updating cursor position on screen
curwin->w_valid_cursor.lnum = 0;
@ -795,15 +795,16 @@ theend:
/// @param tmp_orig
/// @param tmp_new
/// @param tmp_diff
static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff)
static void diff_file(const char *const tmp_orig, const char *const tmp_new,
const char *const tmp_diff)
{
if (*p_dex != NUL) {
// Use 'diffexpr' to generate the diff file.
eval_diff(tmp_orig, tmp_new, tmp_diff);
} else {
size_t len = STRLEN(tmp_orig) + STRLEN(tmp_new) + STRLEN(tmp_diff)
+ STRLEN(p_srr) + 27;
char_u *cmd = xmalloc(len);
const size_t len = (strlen(tmp_orig) + strlen(tmp_new) + strlen(tmp_diff)
+ STRLEN(p_srr) + 27);
char *const cmd = xmalloc(len);
/* We don't want $DIFF_OPTIONS to get in the way. */
if (os_getenv("DIFF_OPTIONS")) {
@ -813,19 +814,17 @@ static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff)
/* Build the diff command and execute it. Always use -a, binary
* differences are of no use. Ignore errors, diff returns
* non-zero when differences have been found. */
vim_snprintf((char *)cmd, len, "diff %s%s%s%s%s %s",
diff_a_works == FALSE ? "" : "-a ",
vim_snprintf(cmd, len, "diff %s%s%s%s%s %s",
diff_a_works ? "-a " : "",
"",
(diff_flags & DIFF_IWHITE) ? "-b " : "",
(diff_flags & DIFF_ICASE) ? "-i " : "",
tmp_orig, tmp_new);
append_redir(cmd, len, p_srr, tmp_diff);
append_redir(cmd, len, (char *) p_srr, tmp_diff);
block_autocmds(); // Avoid ShellCmdPost stuff
(void)call_shell(
cmd,
kShellOptFilter | kShellOptSilent | kShellOptDoOut,
NULL
);
(void)call_shell((char_u *) cmd,
kShellOptFilter | kShellOptSilent | kShellOptDoOut,
NULL);
unblock_autocmds();
xfree(cmd);
}
@ -902,9 +901,11 @@ void ex_diffpatch(exarg_T *eap)
if (*p_pex != NUL) {
// Use 'patchexpr' to generate the new file.
#ifdef UNIX
eval_patch(tmp_orig, fullname != NULL ? fullname : eap->arg, tmp_new);
eval_patch((char *) tmp_orig,
(char *) (fullname != NULL ? fullname : eap->arg),
(char *) tmp_new);
#else
eval_patch(tmp_orig, eap->arg, tmp_new);
eval_patch((char *) tmp_orig, (char *) eap->arg, (char *) tmp_new);
#endif // ifdef UNIX
} else {
// Build the patch command and execute it. Ignore errors. Switch to

34
src/nvim/edit.c
View File

@ -199,7 +199,7 @@ typedef struct insert_state {
int did_restart_edit; // remember if insert mode was restarted
// after a ctrl+o
bool nomove;
uint8_t *ptr;
char_u *ptr;
} InsertState;
@ -270,8 +270,8 @@ static void insert_enter(InsertState *s)
s->ptr = (char_u *)"i";
}
set_vim_var_string(VV_INSERTMODE, s->ptr, 1);
set_vim_var_string(VV_CHAR, NULL, -1); /* clear v:char */
set_vim_var_string(VV_INSERTMODE, (char *) s->ptr, 1);
set_vim_var_string(VV_CHAR, NULL, -1);
apply_autocmds(EVENT_INSERTENTER, NULL, NULL, false, curbuf);
// Make sure the cursor didn't move. Do call check_cursor_col() in
@ -7239,15 +7239,15 @@ static void ins_insert(int replaceState)
return;
}
set_vim_var_string(VV_INSERTMODE,
(char_u *)((State & REPLACE_FLAG) ? "i" :
replaceState == VREPLACE ? "v" :
"r"), 1);
apply_autocmds(EVENT_INSERTCHANGE, NULL, NULL, FALSE, curbuf);
if (State & REPLACE_FLAG)
set_vim_var_string(VV_INSERTMODE, ((State & REPLACE_FLAG) ? "i" :
replaceState == VREPLACE ? "v" :
"r"), 1);
apply_autocmds(EVENT_INSERTCHANGE, NULL, NULL, false, curbuf);
if (State & REPLACE_FLAG) {
State = INSERT | (State & LANGMAP);
else
} else {
State = replaceState | (State & LANGMAP);
}
AppendCharToRedobuff(K_INS);
showmode();
ui_cursor_shape(); /* may show different cursor shape */
@ -8480,22 +8480,22 @@ static colnr_T get_nolist_virtcol(void)
*/
static char_u *do_insert_char_pre(int c)
{
char_u buf[MB_MAXBYTES + 1];
char buf[MB_MAXBYTES + 1];
// Return quickly when there is nothing to do.
if (!has_event(EVENT_INSERTCHARPRE)) {
return NULL;
}
if (has_mbyte) {
buf[(*mb_char2bytes)(c, buf)] = NUL;
buf[(*mb_char2bytes)(c, (char_u *) buf)] = NUL;
} else {
buf[0] = c;
buf[1] = NUL;
}
/* Lock the text to avoid weird things from happening. */
++textlock;
set_vim_var_string(VV_CHAR, buf, -1); /* set v:char */
// Lock the text to avoid weird things from happening.
textlock++;
set_vim_var_string(VV_CHAR, buf, -1);
char_u *res = NULL;
if (apply_autocmds(EVENT_INSERTCHARPRE, NULL, NULL, FALSE, curbuf)) {
@ -8506,8 +8506,8 @@ static char_u *do_insert_char_pre(int c)
res = vim_strsave(get_vim_var_str(VV_CHAR));
}
set_vim_var_string(VV_CHAR, NULL, -1); /* clear v:char */
--textlock;
set_vim_var_string(VV_CHAR, NULL, -1);
textlock--;
return res;
}

165
src/nvim/eval.c
View File

@ -465,6 +465,8 @@ const list_T *eval_msgpack_type_lists[] = {
*/
void eval_init(void)
{
vimvars[VV_VERSION].vv_nr = VIM_VERSION_100;
jobs = pmap_new(uint64_t)();
struct vimvar *p;
@ -768,45 +770,50 @@ void var_redir_stop(void)
redir_varname = NULL;
}
int eval_charconvert(char_u *enc_from, char_u *enc_to, char_u *fname_from, char_u *fname_to)
int eval_charconvert(const char *const enc_from, const char *const enc_to,
const char *const fname_from, const char *const fname_to)
{
int err = FALSE;
int err = false;
set_vim_var_string(VV_CC_FROM, enc_from, -1);
set_vim_var_string(VV_CC_TO, enc_to, -1);
set_vim_var_string(VV_FNAME_IN, fname_from, -1);
set_vim_var_string(VV_FNAME_OUT, fname_to, -1);
if (eval_to_bool(p_ccv, &err, NULL, FALSE))
err = TRUE;
if (eval_to_bool(p_ccv, &err, NULL, false)) {
err = true;
}
set_vim_var_string(VV_CC_FROM, NULL, -1);
set_vim_var_string(VV_CC_TO, NULL, -1);
set_vim_var_string(VV_FNAME_IN, NULL, -1);
set_vim_var_string(VV_FNAME_OUT, NULL, -1);
if (err)
return FAIL;
return OK;
}
int eval_printexpr(char_u *fname, char_u *args)
{
int err = FALSE;
set_vim_var_string(VV_FNAME_IN, fname, -1);
set_vim_var_string(VV_CMDARG, args, -1);
if (eval_to_bool(p_pexpr, &err, NULL, FALSE))
err = TRUE;
set_vim_var_string(VV_FNAME_IN, NULL, -1);
set_vim_var_string(VV_CMDARG, NULL, -1);
if (err) {
os_remove((char *)fname);
return FAIL;
}
return OK;
}
void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile)
int eval_printexpr(const char *const fname, const char *const args)
{
int err = false;
set_vim_var_string(VV_FNAME_IN, fname, -1);
set_vim_var_string(VV_CMDARG, args, -1);
if (eval_to_bool(p_pexpr, &err, NULL, false)) {
err = true;
}
set_vim_var_string(VV_FNAME_IN, NULL, -1);
set_vim_var_string(VV_CMDARG, NULL, -1);
if (err) {
os_remove(fname);
return FAIL;
}
return OK;
}
void eval_diff(const char *const origfile, const char *const newfile,
const char *const outfile)
{
int err = FALSE;
@ -819,7 +826,8 @@ void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile)
set_vim_var_string(VV_FNAME_OUT, NULL, -1);
}
void eval_patch(char_u *origfile, char_u *difffile, char_u *outfile)
void eval_patch(const char *const origfile, const char *const difffile,
const char *const outfile)
{
int err;
@ -17083,20 +17091,6 @@ static int eval_isnamec1(int c)
return ASCII_ISALPHA(c) || c == '_';
}
/*
* Set number v: variable to "val".
*/
void set_vim_var_nr(int idx, long val)
{
vimvars[idx].vv_nr = val;
}
/// Set special v: variable to "val"
void set_vim_var_special(const int idx, const SpecialVarValue val)
{
vimvars[idx].vv_special = val;
}
/*
* Get number v: variable value.
*/
@ -17134,11 +17128,11 @@ dict_T *get_vim_var_dict(int idx) FUNC_ATTR_PURE
*/
void set_vim_var_char(int c)
{
char_u buf[MB_MAXBYTES + 1];
char buf[MB_MAXBYTES + 1];
if (has_mbyte)
buf[(*mb_char2bytes)(c, buf)] = NUL;
else {
if (has_mbyte) {
buf[(*mb_char2bytes)(c, (char_u *) buf)] = NUL;
} else {
buf[0] = c;
buf[1] = NUL;
}
@ -17157,47 +17151,68 @@ void set_vcount(long count, long count1, int set_prevcount)
vimvars[VV_COUNT1].vv_nr = count1;
}
/*
* Set string v: variable to a copy of "val".
*/
void set_vim_var_string (
int idx,
char_u *val,
int len /* length of "val" to use or -1 (whole string) */
)
/// Set number v: variable to the given value
///
/// @param[in] idx Index of variable to set.
/// @param[in] val Value to set to.
void set_vim_var_nr(const VimVarIndex idx, const varnumber_T val)
{
/* Need to do this (at least) once, since we can't initialize a union.
* Will always be invoked when "v:progname" is set. */
vimvars[VV_VERSION].vv_nr = VIM_VERSION_100;
xfree(vimvars[idx].vv_str);
if (val == NULL)
vimvars[idx].vv_str = NULL;
else if (len == -1)
vimvars[idx].vv_str = vim_strsave(val);
else
vimvars[idx].vv_str = vim_strnsave(val, len);
vimvars[idx].vv_nr = val;
}
/*
* Set List v: variable to "val".
*/
void set_vim_var_list(int idx, list_T *val)
/// Set special v: variable to the given value
///
/// @param[in] idx Index of variable to set.
/// @param[in] val Value to set to.
void set_vim_var_special(const VimVarIndex idx, const SpecialVarValue val)
{
vimvars[idx].vv_special = val;
}
/// Set string v: variable to the given string
///
/// @param[in] idx Index of variable to set.
/// @param[in] val Value to set to. Will be copied.
/// @param[in] len Legth of that value or -1 in which case strlen() will be
/// used.
void set_vim_var_string(const VimVarIndex idx, const char *const val,
const ptrdiff_t len)
{
xfree(vimvars[idx].vv_str);
if (val == NULL) {
vimvars[idx].vv_str = NULL;
} else if (len == -1) {
vimvars[idx].vv_str = (char_u *) xstrdup(val);
} else {
vimvars[idx].vv_str = (char_u *) xstrndup(val, (size_t) len);
}
}
/// Set list v: variable to the given list
///
/// @param[in] idx Index of variable to set.
/// @param[in,out] val Value to set to. Reference count will be incremented.
void set_vim_var_list(const VimVarIndex idx, list_T *const val)
{
list_unref(vimvars[idx].vv_list);
vimvars[idx].vv_list = val;
if (val != NULL)
++val->lv_refcount;
if (val != NULL) {
val->lv_refcount++;
}
}
/// Set Dictionary v: variable to "val".
void set_vim_var_dict(int idx, dict_T *val)
/// Set Dictionary v: variable to the given dictionary
///
/// @param[in] idx Index of variable to set.
/// @param[in,out] val Value to set to. Reference count will be incremented.
/// Also keys of the dictionary will be made read-only.
void set_vim_var_dict(const VimVarIndex idx, dict_T *const val)
{
dict_unref(vimvars[idx].vv_dict);
vimvars[idx].vv_dict = val;
if (val != NULL) {
++val->dv_refcount;
val->dv_refcount++;
// Set readonly
dict_set_keys_readonly(val);
}
@ -17208,15 +17223,17 @@ void set_vim_var_dict(int idx, dict_T *val)
*/
void set_reg_var(int c)
{
char_u regname;
char regname;
if (c == 0 || c == ' ')
if (c == 0 || c == ' ') {
regname = '"';
else
} else {
regname = c;
/* Avoid free/alloc when the value is already right. */
if (vimvars[VV_REG].vv_str == NULL || vimvars[VV_REG].vv_str[0] != c)
}
// Avoid free/alloc when the value is already right.
if (vimvars[VV_REG].vv_str == NULL || vimvars[VV_REG].vv_str[0] != c) {
set_vim_var_string(VV_REG, &regname, 1);
}
}
/*

4
src/nvim/eval/decode.c
View File

@ -575,8 +575,8 @@ parse_json_number_check:
tv.vval.v_number = (varnumber_T) nr;
}
if (json_decoder_pop(OBJ(tv, false, *didcomma, *didcolon),
stack, container_stack,
&p, next_map_special, didcomma, didcolon) == FAIL) {
stack, container_stack,
&p, next_map_special, didcomma, didcolon) == FAIL) {
goto parse_json_number_fail;
}
if (*next_map_special) {

105
src/nvim/ex_cmds.c
View File

@ -1326,15 +1326,17 @@ char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
#endif
size_t len = STRLEN(cmd) + 1; // At least enough space for cmd + NULL.
len += is_fish_shell ? sizeof("begin; ""; end") - 1
: sizeof("("")") - 1;
if (itmp != NULL)
if (itmp != NULL) {
len += STRLEN(itmp) + sizeof(" { "" < "" } ") - 1;
if (otmp != NULL)
}
if (otmp != NULL) {
len += STRLEN(otmp) + STRLEN(p_srr) + 2; // two extra spaces (" "),
char_u *buf = xmalloc(len);
}
char *const buf = xmalloc(len);
#if defined(UNIX)
// Put delimiters around the command (for concatenated commands) when
@ -1342,19 +1344,19 @@ char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
if (itmp != NULL || otmp != NULL) {
char *fmt = is_fish_shell ? "begin; %s; end"
: "(%s)";
vim_snprintf((char *)buf, len, fmt, (char *)cmd);
vim_snprintf(buf, len, fmt, (char *)cmd);
} else {
STRCPY(buf, cmd);
strncpy(buf, (char *) cmd, len);
}
if (itmp != NULL) {
STRCAT(buf, " < ");
STRCAT(buf, itmp);
strncat(buf, " < ", len);
strncat(buf, (char *) itmp, len);
}
#else
// For shells that don't understand braces around commands, at least allow
// the use of commands in a pipe.
STRCPY(buf, cmd);
strncpy(buf, cmd, len);
if (itmp != NULL) {
char_u *p;
@ -1362,55 +1364,56 @@ char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp)
// Don't do this when 'shellquote' is not empty, otherwise the
// redirection would be inside the quotes.
if (*p_shq == NUL) {
p = vim_strchr(buf, '|');
if (p != NULL)
*p = NUL;
}
STRCAT(buf, " < ");
STRCAT(buf, itmp);
if (*p_shq == NUL) {
p = vim_strchr(cmd, '|');
p = strchr(buf, '|');
if (p != NULL) {
STRCAT(buf, " "); // Insert a space before the '|' for DOS
STRCAT(buf, p);
*p = NUL;
}
}
strncat(buf, " < ", len);
strncat(buf, (char *) itmp, len);
if (*p_shq == NUL) {
p = strchr(cmd, '|');
if (p != NULL) {
strncat(buf, " ", len); // Insert a space before the '|' for DOS
strncat(buf, p, len);
}
}
}
#endif
if (otmp != NULL) {
append_redir(buf, len, p_srr, otmp);
append_redir(buf, len, (char *) p_srr, (char *) otmp);
}
return buf;
return (char_u *) buf;
}
/*
* Append output redirection for file "fname" to the end of string buffer
* "buf[buflen]"
* Works with the 'shellredir' and 'shellpipe' options.
* The caller should make sure that there is enough room:
* STRLEN(opt) + STRLEN(fname) + 3
*/
void append_redir(char_u *buf, size_t buflen, char_u *opt, char_u *fname)
/// Append output redirection for the given file to the end of the buffer
///
/// @param[out] buf Buffer to append to.
/// @param[in] buflen Buffer length.
/// @param[in] opt Separator or format string to append: will append
/// `printf(' ' . opt, fname)` if `%s` is found in `opt` or
/// a space, opt, a space and then fname if `%s` is not found
/// there.
/// @param[in] fname File name to append.
void append_redir(char *const buf, const size_t buflen,
const char *const opt, const char *const fname)
{
char_u *p;
char_u *end;
end = buf + STRLEN(buf);
/* find "%s" */
for (p = opt; (p = vim_strchr(p, '%')) != NULL; ++p) {
if (p[1] == 's') /* found %s */
char *const end = buf + strlen(buf);
// find "%s"
const char *p = opt;
for (; (p = strchr(p, '%')) != NULL; p++) {
if (p[1] == 's') { // found %s
break;
if (p[1] == '%') /* skip %% */
++p;
} else if (p[1] == '%') { // skip %%
p++;
}
}
if (p != NULL) {
*end = ' '; /* not really needed? Not with sh, ksh or bash */
vim_snprintf((char *)end + 1, (size_t)(buflen - (end + 1 - buf)),
(char *)opt, (char *)fname);
} else
vim_snprintf((char *)end, (size_t)(buflen - (end - buf)),
" %s %s",
(char *)opt, (char *)fname);
*end = ' '; // not really needed? Not with sh, ksh or bash
vim_snprintf(end + 1, (size_t) (buflen - (end + 1 - buf)), opt, fname);
} else {
vim_snprintf(end, (size_t) (buflen - (end - buf)), " %s %s", opt, fname);
}
}
void print_line_no_prefix(linenr_T lnum, int use_number, int list)
@ -2093,15 +2096,13 @@ do_ecmd (
if ((command != NULL || newlnum > (linenr_T)0)
&& *get_vim_var_str(VV_SWAPCOMMAND) == NUL) {
char_u *p;
/* Set v:swapcommand for the SwapExists autocommands. */
size_t len = (command != NULL) ? STRLEN(command) + 3 : 30;
p = xmalloc(len);
// Set v:swapcommand for the SwapExists autocommands.
const size_t len = (command != NULL) ? STRLEN(command) + 3 : 30;
char *const p = xmalloc(len);
if (command != NULL) {
vim_snprintf((char *)p, len, ":%s\r", command);
vim_snprintf(p, len, ":%s\r", command);
} else {
vim_snprintf((char *)p, len, "%" PRId64 "G", (int64_t)newlnum);
vim_snprintf(p, len, "%" PRId64 "G", (int64_t)newlnum);
}
set_vim_var_string(VV_SWAPCOMMAND, p, -1);
did_set_swapcommand = TRUE;

14
src/nvim/ex_cmds2.c
View File

@ -3168,27 +3168,27 @@ static char_u *get_mess_env(void)
*/
void set_lang_var(void)
{
char_u *loc;
const char *loc;
# ifdef HAVE_GET_LOCALE_VAL
loc = (char_u *)get_locale_val(LC_CTYPE);
loc = get_locale_val(LC_CTYPE);
# else
/* setlocale() not supported: use the default value */
loc = (char_u *)"C";
// setlocale() not supported: use the default value
loc = "C";
# endif
set_vim_var_string(VV_CTYPE, loc, -1);
/* When LC_MESSAGES isn't defined use the value from $LC_MESSAGES, fall
* back to LC_CTYPE if it's empty. */
# ifdef HAVE_WORKING_LIBINTL
loc = get_mess_env();
loc = (char *) get_mess_env();
# else
loc = (char_u *)get_locale_val(LC_MESSAGES);
loc = get_locale_val(LC_MESSAGES);
# endif
set_vim_var_string(VV_LANG, loc, -1);
# ifdef HAVE_GET_LOCALE_VAL
loc = (char_u *)get_locale_val(LC_TIME);
loc = get_locale_val(LC_TIME);
# endif
set_vim_var_string(VV_LC_TIME, loc, -1);
}

58
src/nvim/ex_docmd.c
View File

@ -7421,10 +7421,10 @@ static int mksession_nl = FALSE; /* use NL only in put_eol() */
static void ex_mkrc(exarg_T *eap)
{
FILE *fd;
int failed = FALSE;
int view_session = FALSE;
int using_vdir = FALSE; /* using 'viewdir'? */
char_u *viewFile = NULL;
int failed = false;
int view_session = false;
int using_vdir = false; // using 'viewdir'?
char *viewFile = NULL;
unsigned *flagp;
if (eap->cmdidx == CMD_mksession || eap->cmdidx == CMD_mkview) {
@ -7435,32 +7435,34 @@ static void ex_mkrc(exarg_T *eap)
* short file name when 'acd' is set, that is checked later. */
did_lcd = FALSE;
char_u *fname;
/* ":mkview" or ":mkview 9": generate file name with 'viewdir' */
char *fname;
// ":mkview" or ":mkview 9": generate file name with 'viewdir'
if (eap->cmdidx == CMD_mkview
&& (*eap->arg == NUL
|| (ascii_isdigit(*eap->arg) && eap->arg[1] == NUL))) {
eap->forceit = TRUE;
fname = (char_u *)get_view_file(*eap->arg);
if (fname == NULL)
eap->forceit = true;
fname = get_view_file(*eap->arg);
if (fname == NULL) {
return;
}
viewFile = fname;
using_vdir = TRUE;
} else if (*eap->arg != NUL)
fname = eap->arg;
else if (eap->cmdidx == CMD_mkvimrc)
fname = (char_u *)VIMRC_FILE;
else if (eap->cmdidx == CMD_mksession)
fname = (char_u *)SESSION_FILE;
else
fname = (char_u *)EXRC_FILE;
using_vdir = true;
} else if (*eap->arg != NUL) {
fname = (char *) eap->arg;
} else if (eap->cmdidx == CMD_mkvimrc) {
fname = VIMRC_FILE;
} else if (eap->cmdidx == CMD_mksession) {
fname = SESSION_FILE;
} else {
fname = EXRC_FILE;
}
/* When using 'viewdir' may have to create the directory. */
if (using_vdir && !os_isdir(p_vdir)) {
vim_mkdir_emsg(p_vdir, 0755);
}
fd = open_exfile(fname, eap->forceit, WRITEBIN);
fd = open_exfile((char_u *) fname, eap->forceit, WRITEBIN);
if (fd != NULL) {
if (eap->cmdidx == CMD_mkview)
flagp = &vop_flags;
@ -7504,8 +7506,9 @@ static void ex_mkrc(exarg_T *eap)
|| os_chdir((char *)dirnow) != 0)
*dirnow = NUL;
if (*dirnow != NUL && (ssop_flags & SSOP_SESDIR)) {
if (vim_chdirfile(fname) == OK)
shorten_fnames(TRUE);
if (vim_chdirfile((char_u *) fname) == OK) {
shorten_fnames(true);
}
} else if (*dirnow != NUL
&& (ssop_flags & SSOP_CURDIR) && globaldir != NULL) {
if (os_chdir((char *)globaldir) == 0)
@ -7550,15 +7553,14 @@ static void ex_mkrc(exarg_T *eap)
failed |= fclose(fd);
if (failed)
if (failed) {
EMSG(_(e_write));
else if (eap->cmdidx == CMD_mksession) {
/* successful session write - set this_session var */
char_u *tbuf;
tbuf = xmalloc(MAXPATHL);
if (vim_FullName((char *)fname, (char *)tbuf, MAXPATHL, FALSE) == OK)
} else if (eap->cmdidx == CMD_mksession) {
// successful session write - set this_session var
char *const tbuf = xmalloc(MAXPATHL);
if (vim_FullName(fname, tbuf, MAXPATHL, false) == OK) {
set_vim_var_string(VV_THIS_SESSION, tbuf, -1);
}
xfree(tbuf);
}
#ifdef MKSESSION_NL

38
src/nvim/ex_eval.c
View File

@ -569,17 +569,19 @@ static void catch_exception(except_T *excp)
{
excp->caught = caught_stack;
caught_stack = excp;
set_vim_var_string(VV_EXCEPTION, excp->value, -1);
set_vim_var_string(VV_EXCEPTION, (char *) excp->value, -1);
if (*excp->throw_name != NUL) {
if (excp->throw_lnum != 0)
if (excp->throw_lnum != 0) {
vim_snprintf((char *)IObuff, IOSIZE, _("%s, line %" PRId64),
excp->throw_name, (int64_t)excp->throw_lnum);
else
excp->throw_name, (int64_t)excp->throw_lnum);
} else {
vim_snprintf((char *)IObuff, IOSIZE, "%s", excp->throw_name);
set_vim_var_string(VV_THROWPOINT, IObuff, -1);
} else
/* throw_name not set on an exception from a command that was typed. */
}
set_vim_var_string(VV_THROWPOINT, (char *) IObuff, -1);
} else {
// throw_name not set on an exception from a command that was typed.
set_vim_var_string(VV_THROWPOINT, NULL, -1);
}
if (p_verbose >= 13 || debug_break_level > 0) {
int save_msg_silent = msg_silent;
@ -614,20 +616,22 @@ static void finish_exception(except_T *excp)
EMSG(_(e_internal));
caught_stack = caught_stack->caught;
if (caught_stack != NULL) {
set_vim_var_string(VV_EXCEPTION, caught_stack->value, -1);
set_vim_var_string(VV_EXCEPTION, (char *) caught_stack->value, -1);
if (*caught_stack->throw_name != NUL) {
if (caught_stack->throw_lnum != 0)
if (caught_stack->throw_lnum != 0) {
vim_snprintf((char *)IObuff, IOSIZE,
_("%s, line %" PRId64), caught_stack->throw_name,
(int64_t)caught_stack->throw_lnum);
else
_("%s, line %" PRId64), caught_stack->throw_name,
(int64_t)caught_stack->throw_lnum);
} else {
vim_snprintf((char *)IObuff, IOSIZE, "%s",
caught_stack->throw_name);
set_vim_var_string(VV_THROWPOINT, IObuff, -1);
} else
/* throw_name not set on an exception from a command that was
* typed. */
caught_stack->throw_name);
}
set_vim_var_string(VV_THROWPOINT, (char *) IObuff, -1);
} else {
// throw_name not set on an exception from a command that was
// typed.
set_vim_var_string(VV_THROWPOINT, NULL, -1);
}
} else {
set_vim_var_string(VV_EXCEPTION, NULL, -1);
set_vim_var_string(VV_THROWPOINT, NULL, -1);

58
src/nvim/fileio.c
View File

@ -2139,9 +2139,10 @@ readfile_charconvert (
else {
close(*fdp); /* close the input file, ignore errors */
*fdp = -1;
if (eval_charconvert(fenc, enc_utf8 ? (char_u *)"utf-8" : p_enc,
fname, tmpname) == FAIL)
if (eval_charconvert((char *) fenc, enc_utf8 ? "utf-8" : (char *) p_enc,
(char *) fname, (char *) tmpname) == FAIL) {
errmsg = (char_u *)_("Conversion with 'charconvert' failed");
}
if (errmsg == NULL && (*fdp = os_open((char *)tmpname, O_RDONLY, 0)) < 0) {
errmsg = (char_u *)_("can't read output of 'charconvert'");
}
@ -3435,9 +3436,9 @@ restore_backup:
* with 'charconvert' to (overwrite) the output file.
*/
if (end != 0) {
if (eval_charconvert(enc_utf8 ? (char_u *)"utf-8" : p_enc, fenc,
wfname, fname) == FAIL) {
write_info.bw_conv_error = TRUE;
if (eval_charconvert(enc_utf8 ? "utf-8" : (char *) p_enc, (char *) fenc,
(char *) wfname, (char *) fname) == FAIL) {
write_info.bw_conv_error = true;
end = 0;
}
}
@ -4740,7 +4741,6 @@ buf_check_timestamp (
{
int retval = 0;
char_u *path;
char_u *tbuf;
char *mesg = NULL;
char *mesg2 = "";
int helpmesg = FALSE;
@ -4810,14 +4810,12 @@ buf_check_timestamp (
else
reason = "time";
/*
* Only give the warning if there are no FileChangedShell
* autocommands.
* Avoid being called recursively by setting "busy".
*/
busy = TRUE;
set_vim_var_string(VV_FCS_REASON, (char_u *)reason, -1);
set_vim_var_string(VV_FCS_CHOICE, (char_u *)"", -1);
// Only give the warning if there are no FileChangedShell
// autocommands.
// Avoid being called recursively by setting "busy".
busy = true;
set_vim_var_string(VV_FCS_REASON, reason, -1);
set_vim_var_string(VV_FCS_CHOICE, "", -1);
++allbuf_lock;
n = apply_autocmds(EVENT_FILECHANGEDSHELL,
buf->b_fname, buf->b_fname, FALSE, buf);
@ -4876,35 +4874,39 @@ buf_check_timestamp (
if (mesg != NULL) {
path = home_replace_save(buf, buf->b_fname);
if (!helpmesg)
if (!helpmesg) {
mesg2 = "";
tbuf = xmalloc(STRLEN(path) + STRLEN(mesg) + STRLEN(mesg2) + 2);
sprintf((char *)tbuf, mesg, path);
/* Set warningmsg here, before the unimportant and output-specific
* mesg2 has been appended. */
}
const size_t tbuf_len = STRLEN(path) + STRLEN(mesg) + STRLEN(mesg2) + 2;
char *const tbuf = xmalloc(tbuf_len);
snprintf(tbuf, tbuf_len, mesg, path);
// Set warningmsg here, before the unimportant and output-specific
// mesg2 has been appended.
set_vim_var_string(VV_WARNINGMSG, tbuf, -1);
if (can_reload) {
if (*mesg2 != NUL) {
STRCAT(tbuf, "\n");
STRCAT(tbuf, mesg2);
strncat(tbuf, "\n", tbuf_len);
strncat(tbuf, mesg2, tbuf_len);
}
if (do_dialog(VIM_WARNING, (char_u *) _("Warning"), (char_u *) tbuf,
(char_u *) _("&OK\n&Load File"), 1, NULL, true) == 2) {
reload = true;
}
if (do_dialog(VIM_WARNING, (char_u *)_("Warning"), tbuf,
(char_u *)_("&OK\n&Load File"), 1, NULL, TRUE) == 2)
reload = TRUE;
} else if (State > NORMAL_BUSY || (State & CMDLINE) || already_warned) {
if (*mesg2 != NUL) {
STRCAT(tbuf, "; ");
STRCAT(tbuf, mesg2);
strncat(tbuf, "; ", tbuf_len);
strncat(tbuf, mesg2, tbuf_len);
}
EMSG(tbuf);
retval = 2;
} else {
if (!autocmd_busy) {
msg_start();
msg_puts_attr(tbuf, hl_attr(HLF_E) + MSG_HIST);
if (*mesg2 != NUL)
msg_puts_attr((char_u *) tbuf, hl_attr(HLF_E) + MSG_HIST);
if (*mesg2 != NUL) {
msg_puts_attr((char_u *)mesg2,
hl_attr(HLF_W) + MSG_HIST);
}
msg_clr_eos();
(void)msg_end();
if (emsg_silent == 0) {

12
src/nvim/fold.c
View File

@ -1699,14 +1699,14 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume,
did_emsg = FALSE;
if (*wp->w_p_fdt != NUL) {
char_u dashes[MAX_LEVEL + 2];
char dashes[MAX_LEVEL + 2];
win_T *save_curwin;
int level;
char_u *p;
/* Set "v:foldstart" and "v:foldend". */
set_vim_var_nr(VV_FOLDSTART, lnum);
set_vim_var_nr(VV_FOLDEND, lnume);
// Set "v:foldstart" and "v:foldend".
set_vim_var_nr(VV_FOLDSTART, (varnumber_T) lnum);
set_vim_var_nr(VV_FOLDEND, (varnumber_T) lnume);
/* Set "v:folddashes" to a string of "level" dashes. */
/* Set "v:foldlevel" to "level". */
@ -1716,7 +1716,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume,
memset(dashes, '-', (size_t)level);
dashes[level] = NUL;
set_vim_var_string(VV_FOLDDASHES, dashes, -1);
set_vim_var_nr(VV_FOLDLEVEL, (long)level);
set_vim_var_nr(VV_FOLDLEVEL, (varnumber_T) level);
/* skip evaluating foldtext on errors */
if (!got_fdt_error) {
@ -2676,7 +2676,7 @@ static void foldlevelExpr(fline_T *flp)
win = curwin;
curwin = flp->wp;
curbuf = flp->wp->w_buffer;
set_vim_var_nr(VV_LNUM, lnum);
set_vim_var_nr(VV_LNUM, (varnumber_T) lnum);
flp->start = 0;
flp->had_end = flp->end;

8
src/nvim/hardcopy.c
View File

@ -2780,11 +2780,13 @@ void mch_print_end(prt_settings_T *psettings)
}
prt_message((char_u *)_("Sending to printer..."));
/* Not printing to a file: use 'printexpr' to print the file. */
if (eval_printexpr(prt_ps_file_name, psettings->arguments) == FAIL)
// Not printing to a file: use 'printexpr' to print the file.
if (eval_printexpr((char *) prt_ps_file_name, (char *) psettings->arguments)
== FAIL) {
EMSG(_("E365: Failed to print PostScript file"));
else
} else {
prt_message((char_u *)_("Print job sent."));
}
}
mch_print_cleanup();

2
src/nvim/indent.c
View File

@ -529,7 +529,7 @@ int get_expr_indent(void)
save_pos = curwin->w_cursor;
save_curswant = curwin->w_curswant;
save_set_curswant = curwin->w_set_curswant;
set_vim_var_nr(VV_LNUM, curwin->w_cursor.lnum);
set_vim_var_nr(VV_LNUM, (varnumber_T) curwin->w_cursor.lnum);
if (use_sandbox) {
sandbox++;

13
src/nvim/main.c
View File

@ -238,8 +238,8 @@ int main(int argc, char **argv)
check_and_set_isatty(&params);
// Get the name with which Nvim was invoked, with and without path.
set_vim_var_string(VV_PROGPATH, (char_u *)argv[0], -1);
set_vim_var_string(VV_PROGNAME, path_tail((char_u *)argv[0]), -1);
set_vim_var_string(VV_PROGPATH, argv[0], -1);
set_vim_var_string(VV_PROGNAME, (char *) path_tail((char_u *) argv[0]), -1);
event_init();
/*
@ -1141,10 +1141,11 @@ scripterror:
/* If there is a "+123" or "-c" command, set v:swapcommand to the first
* one. */
if (parmp->n_commands > 0) {
p = xmalloc(STRLEN(parmp->commands[0]) + 3);
sprintf((char *)p, ":%s\r", parmp->commands[0]);
set_vim_var_string(VV_SWAPCOMMAND, p, -1);
xfree(p);
const size_t swcmd_len = STRLEN(parmp->commands[0]) + 3;
char *const swcmd = xmalloc(swcmd_len);
snprintf(swcmd, swcmd_len, ":%s\r", parmp->commands[0]);
set_vim_var_string(VV_SWAPCOMMAND, swcmd, -1);
xfree(swcmd);
}
TIME_MSG("parsing arguments");
}

2
src/nvim/memline.c
View File

@ -3194,7 +3194,7 @@ attention_message (
*/
static int do_swapexists(buf_T *buf, char_u *fname)
{
set_vim_var_string(VV_SWAPNAME, fname, -1);
set_vim_var_string(VV_SWAPNAME, (char *) fname, -1);
set_vim_var_string(VV_SWAPCHOICE, NULL, -1);
/* Trigger SwapExists autocommands with <afile> set to the file being

38
src/nvim/message.c
View File

@ -143,10 +143,11 @@ msg_attr_keep (
{
static int entered = 0;
int retval;
char_u *buf = NULL;
char_u *buf = NULL;
if (attr == 0)
set_vim_var_string(VV_STATUSMSG, s, -1);
if (attr == 0) {
set_vim_var_string(VV_STATUSMSG, (char *) s, -1);
}
/*
* It is possible that displaying a messages causes a problem (e.g.,
@ -497,8 +498,8 @@ int emsg(char_u *s)
return TRUE;
}
/* set "v:errmsg", also when using ":silent! cmd" */
set_vim_var_string(VV_ERRMSG, s, -1);
// set "v:errmsg", also when using ":silent! cmd"
set_vim_var_string(VV_ERRMSG, (char *) s, -1);
/*
* When using ":silent! cmd" ignore error messages.
@ -1755,25 +1756,24 @@ static void msg_scroll_up(void)
static void inc_msg_scrolled(void)
{
if (*get_vim_var_str(VV_SCROLLSTART) == NUL) {
char_u *p = sourcing_name;
char_u *tofree = NULL;
int len;
char *p = (char *) sourcing_name;
char *tofree = NULL;
/* v:scrollstart is empty, set it to the script/function name and line
* number */
if (p == NULL)
p = (char_u *)_("Unknown");
else {
len = (int)STRLEN(p) + 40;
// v:scrollstart is empty, set it to the script/function name and line
// number
if (p == NULL) {
p = _("Unknown");
} else {
size_t len = strlen(p) + 40;
tofree = xmalloc(len);
vim_snprintf((char *)tofree, len, _("%s line %" PRId64),
p, (int64_t)sourcing_lnum);
vim_snprintf(tofree, len, _("%s line %" PRId64),
p, (int64_t) sourcing_lnum);
p = tofree;
}
set_vim_var_string(VV_SCROLLSTART, p, -1);
xfree(tofree);
}
++msg_scrolled;
msg_scrolled++;
}
static msgchunk_T *last_msgchunk = NULL; /* last displayed text */
@ -2540,7 +2540,7 @@ void give_warning(char_u *message, bool hl) FUNC_ATTR_NONNULL_ARG(1)
/* Don't want a hit-enter prompt here. */
++no_wait_return;
set_vim_var_string(VV_WARNINGMSG, message, -1);
set_vim_var_string(VV_WARNINGMSG, (char *) message, -1);
xfree(keep_msg);
keep_msg = NULL;
if (hl)
@ -3054,7 +3054,7 @@ int vim_snprintf_add(char *str, size_t str_m, char *fmt, ...)
return str_l;
}
int vim_snprintf(char *str, size_t str_m, char *fmt, ...)
int vim_snprintf(char *str, size_t str_m, const char *fmt, ...)
{
va_list ap;
int str_l;

2
src/nvim/misc1.c
View File

@ -2250,7 +2250,7 @@ change_warning (
msg_col = col;
msg_source(hl_attr(HLF_W));
MSG_PUTS_ATTR(_(w_readonly), hl_attr(HLF_W) | MSG_HIST);
set_vim_var_string(VV_WARNINGMSG, (char_u *)_(w_readonly), -1);
set_vim_var_string(VV_WARNINGMSG, _(w_readonly), -1);
msg_clr_eos();
(void)msg_end();
if (msg_silent == 0 && !silent_mode) {

5
src/nvim/misc2.c
View File

@ -327,9 +327,10 @@ int call_shell(char_u *cmd, ShellOpts opts, char_u *extra_shell_arg)
}
}
set_vim_var_nr(VV_SHELL_ERROR, (long)retval);
if (do_profiling == PROF_YES)
set_vim_var_nr(VV_SHELL_ERROR, (varnumber_T) retval);
if (do_profiling == PROF_YES) {
prof_child_exit(&wait_time);
}
return retval;
}

2
src/nvim/msgpack_rpc/server.c
View File

@ -59,7 +59,7 @@ static void set_vservername(garray_T *srvs)
char *default_server = (srvs->ga_len > 0)
? ((SocketWatcher **)srvs->ga_data)[0]->addr
: NULL;
set_vim_var_string(VV_SEND_SERVER, (char_u *)default_server, -1);
set_vim_var_string(VV_SEND_SERVER, default_server, -1);
}
/// Teardown the server module

11
src/nvim/normal.c
View File

@ -7057,18 +7057,17 @@ static void nv_operator(cmdarg_T *cap)
*/
static void set_op_var(int optype)
{
char_u opchars[3];
if (optype == OP_NOP)
if (optype == OP_NOP) {
set_vim_var_string(VV_OP, NULL, 0);
else {
} else {
char opchars[3];
int opchar0 = get_op_char(optype);
assert(opchar0 >= 0 && opchar0 <= UCHAR_MAX);
opchars[0] = (char_u)opchar0;
opchars[0] = (char) opchar0;
int opchar1 = get_extra_op_char(optype);
assert(opchar1 >= 0 && opchar1 <= UCHAR_MAX);
opchars[1] = (char_u)opchar1;
opchars[1] = (char) opchar1;
opchars[2] = NUL;
set_vim_var_string(VV_OP, opchars, -1);

47
src/nvim/option.c
View File

@ -1448,7 +1448,7 @@ do_set (
char_u *oldval = NULL; // previous value if *varp
char_u *newval;
char_u *origval = NULL;
char_u *saved_origval = NULL;
char *saved_origval = NULL;
unsigned newlen;
int comma;
int bs;
@ -1725,7 +1725,7 @@ do_set (
if (!starting && origval != NULL) {
// origval may be freed by
// did_set_string_option(), make a copy.
saved_origval = vim_strsave(origval);
saved_origval = xstrdup((char *) origval);
}
/* Handle side effects, and set the global value for
@ -1740,11 +1740,10 @@ do_set (
}
if (saved_origval != NULL) {
char_u buf_type[7];
vim_snprintf((char *)buf_type, ARRAY_SIZE(buf_type), "%s",
char buf_type[7];
vim_snprintf(buf_type, ARRAY_SIZE(buf_type), "%s",
(opt_flags & OPT_LOCAL) ? "local" : "global");
set_vim_var_string(VV_OPTION_NEW,
*(char_u **)varp, -1);
set_vim_var_string(VV_OPTION_NEW, *(char **) varp, -1);
set_vim_var_string(VV_OPTION_OLD, saved_origval, -1);
set_vim_var_string(VV_OPTION_TYPE, buf_type, -1);
apply_autocmds(EVENT_OPTIONSET,
@ -2324,7 +2323,7 @@ set_string_option (
char_u *s;
char_u **varp;
char_u *oldval;
char_u *saved_oldval = NULL;
char *saved_oldval = NULL;
char_u *r = NULL;
if (options[opt_idx].var == NULL) /* don't set hidden option */
@ -2340,7 +2339,7 @@ set_string_option (
*varp = s;
if (!starting) {
saved_oldval = vim_strsave(oldval);
saved_oldval = xstrdup((char *) oldval);
}
if ((r = did_set_string_option(opt_idx, varp, (int)true, oldval, NULL,
@ -2349,10 +2348,10 @@ set_string_option (
// call autocommand after handling side effects
if (saved_oldval != NULL) {
char_u buf_type[7];
vim_snprintf((char *)buf_type, ARRAY_SIZE(buf_type), "%s",
char buf_type[7];
vim_snprintf(buf_type, ARRAY_SIZE(buf_type), "%s",
(opt_flags & OPT_LOCAL) ? "local" : "global");
set_vim_var_string(VV_OPTION_NEW, *varp, -1);
set_vim_var_string(VV_OPTION_NEW, (char *) (*varp), -1);
set_vim_var_string(VV_OPTION_OLD, saved_oldval, -1);
set_vim_var_string(VV_OPTION_TYPE, buf_type, -1);
apply_autocmds(EVENT_OPTIONSET,
@ -3800,7 +3799,7 @@ set_bool_option (
msg_source(hl_attr(HLF_W));
MSG_ATTR(_(w_arabic), hl_attr(HLF_W));
set_vim_var_string(VV_WARNINGMSG, (char_u *)_(w_arabic), -1);
set_vim_var_string(VV_WARNINGMSG, _(w_arabic), -1);
}
/* set 'delcombine' */
@ -3847,14 +3846,14 @@ set_bool_option (
options[opt_idx].flags |= P_WAS_SET;
if (!starting) {
char_u buf_old[2];
char_u buf_new[2];
char_u buf_type[7];
vim_snprintf((char *)buf_old, ARRAY_SIZE(buf_old), "%d",
char buf_old[2];
char buf_new[2];
char buf_type[7];
vim_snprintf(buf_old, ARRAY_SIZE(buf_old), "%d",
old_value ? true: false);
vim_snprintf((char *)buf_new, ARRAY_SIZE(buf_new), "%d",
vim_snprintf(buf_new, ARRAY_SIZE(buf_new), "%d",
value ? true: false);
vim_snprintf((char *)buf_type, ARRAY_SIZE(buf_type), "%s",
vim_snprintf(buf_type, ARRAY_SIZE(buf_type), "%s",
(opt_flags & OPT_LOCAL) ? "local" : "global");
set_vim_var_string(VV_OPTION_NEW, buf_new, -1);
set_vim_var_string(VV_OPTION_OLD, buf_old, -1);
@ -4237,12 +4236,12 @@ set_num_option (
options[opt_idx].flags |= P_WAS_SET;
if (!starting && errmsg == NULL) {
char_u buf_old[NUMBUFLEN];
char_u buf_new[NUMBUFLEN];
char_u buf_type[7];
vim_snprintf((char *)buf_old, ARRAY_SIZE(buf_old), "%ld", old_value);
vim_snprintf((char *)buf_new, ARRAY_SIZE(buf_new), "%ld", value);
vim_snprintf((char *)buf_type, ARRAY_SIZE(buf_type), "%s",
char buf_old[NUMBUFLEN];
char buf_new[NUMBUFLEN];
char buf_type[7];
vim_snprintf(buf_old, ARRAY_SIZE(buf_old), "%ld", old_value);
vim_snprintf(buf_new, ARRAY_SIZE(buf_new), "%ld", value);
vim_snprintf(buf_type, ARRAY_SIZE(buf_type), "%s",
(opt_flags & OPT_LOCAL) ? "local" : "global");
set_vim_var_string(VV_OPTION_NEW, buf_new, -1);
set_vim_var_string(VV_OPTION_OLD, buf_old, -1);

15
src/nvim/path.c
View File

@ -1495,13 +1495,12 @@ void simplify_filename(char_u *filename)
} while (*p != NUL);
}
static char_u *eval_includeexpr(char_u *ptr, size_t len)
static char *eval_includeexpr(const char *const ptr, const size_t len)
{
assert(len <= INT_MAX);
set_vim_var_string(VV_FNAME, ptr, (int)len);
char_u *res = eval_to_string_safe(curbuf->b_p_inex, NULL,
was_set_insecurely((char_u *)"includeexpr",
OPT_LOCAL));
set_vim_var_string(VV_FNAME, ptr, (ptrdiff_t) len);
char *res = (char *) eval_to_string_safe(
curbuf->b_p_inex, NULL, was_set_insecurely((char_u *)"includeexpr",
OPT_LOCAL));
set_vim_var_string(VV_FNAME, NULL, 0);
return res;
}
@ -1523,7 +1522,7 @@ find_file_name_in_path (
char_u *tofree = NULL;
if ((options & FNAME_INCL) && *curbuf->b_p_inex != NUL) {
tofree = eval_includeexpr(ptr, len);
tofree = (char_u *) eval_includeexpr((char *) ptr, len);
if (tofree != NULL) {
ptr = tofree;
len = STRLEN(ptr);
@ -1540,7 +1539,7 @@ find_file_name_in_path (
*/
if (file_name == NULL
&& !(options & FNAME_INCL) && *curbuf->b_p_inex != NUL) {
tofree = eval_includeexpr(ptr, len);
tofree = (char_u *) eval_includeexpr((char *) ptr, len);
if (tofree != NULL) {
ptr = tofree;
len = STRLEN(ptr);

38
src/nvim/quickfix.c
View File

@ -2440,8 +2440,6 @@ int grep_internal(cmdidx_T cmdidx)
void ex_make(exarg_T *eap)
{
char_u *fname;
char_u *cmd;
size_t len;
win_T *wp = NULL;
qf_info_T *qi = &ql_info;
int res;
@ -2479,30 +2477,28 @@ void ex_make(exarg_T *eap)
return;
os_remove((char *)fname); // in case it's not unique
/*
* If 'shellpipe' empty: don't redirect to 'errorfile'.
*/
len = STRLEN(p_shq) * 2 + STRLEN(eap->arg) + 1;
// If 'shellpipe' empty: don't redirect to 'errorfile'.
const size_t len = (STRLEN(p_shq) * 2 + STRLEN(eap->arg) + 1
+ (*p_sp == NUL
? 0
: STRLEN(p_sp) + STRLEN(fname) + 3));
char *const cmd = xmalloc(len);
snprintf(cmd, len, "%s%s%s", (char *)p_shq, (char *)eap->arg,
(char *)p_shq);
if (*p_sp != NUL) {
len += STRLEN(p_sp) + STRLEN(fname) + 3;
append_redir(cmd, len, (char *) p_sp, (char *) fname);
}
// Output a newline if there's something else than the :make command that
// was typed (in which case the cursor is in column 0).
if (msg_col == 0) {
msg_didout = false;
}
cmd = xmalloc(len);
sprintf((char *)cmd, "%s%s%s", (char *)p_shq, (char *)eap->arg,
(char *)p_shq);
if (*p_sp != NUL)
append_redir(cmd, len, p_sp, fname);
/*
* Output a newline if there's something else than the :make command that
* was typed (in which case the cursor is in column 0).
*/
if (msg_col == 0)
msg_didout = FALSE;
msg_start();
MSG_PUTS(":!");
msg_outtrans(cmd); /* show what we are doing */
msg_outtrans((char_u *) cmd); // show what we are doing
/* let the shell know if we are redirecting output or not */
do_shell(cmd, *p_sp != NUL ? kShellOptDoOut : 0);
// let the shell know if we are redirecting output or not
do_shell((char_u *) cmd, *p_sp != NUL ? kShellOptDoOut : 0);
res = qf_init(wp, fname, (eap->cmdidx != CMD_make

2
src/nvim/tag.c
View File

@ -872,7 +872,7 @@ do_tag (
/* Let the SwapExists event know what tag we are jumping to. */
vim_snprintf((char *)IObuff, IOSIZE, ":ta %s\r", name);
set_vim_var_string(VV_SWAPCOMMAND, IObuff, -1);
set_vim_var_string(VV_SWAPCOMMAND, (char *) IObuff, -1);
/*
* Jump to the desired match.