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

Merge pull request #20026 from dundargoc/refactor/char_u/7

Browse Source 
refactor: replace char_u with char 7: remove `vim_strnsave`
This commit is contained in:
bfredl 2022-09-02 17:06:00 +02:00 committed by GitHub
commit 69456f3414
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
49 changed files with 742 additions and 776 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/nvim/change.c
View File

@ -599,7 +599,7 @@ void ins_bytes_len(char *p, size_t len)
size_t n;
for (size_t i = 0; i < len; i += n) {
// avoid reading past p[len]
n = (size_t)utfc_ptr2len_len((char_u *)p + i, (int)(len - i));
n = (size_t)utfc_ptr2len_len(p + i, (int)(len - i));
ins_char_bytes(p + i, n);
}
}
@ -828,7 +828,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
col = n;
count = utf_ptr2len(oldp + n);
n += count;
} while (utf_composinglike((char_u *)oldp + col, (char_u *)oldp + n));
} while (utf_composinglike(oldp + col, oldp + n));
fixpos = false;
}
}
@ -1036,7 +1036,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
colnr_T mincol = curwin->w_cursor.col + 1;
// make a copy of the current line so we can mess with it
char *saved_line = (char *)vim_strsave(get_cursor_line_ptr());
char *saved_line = (char *)vim_strsave((char_u *)get_cursor_line_ptr());
if (State & VREPLACE_FLAG) {
// With MODE_VREPLACE we make a copy of the next line, which we will be
@ -1181,7 +1181,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
if ((pos = findmatch(NULL, '(')) != NULL) {
curwin->w_cursor.lnum = pos->lnum;
newindent = get_indent();
ptr = (char *)get_cursor_line_ptr();
ptr = get_cursor_line_ptr();
}
}
// If last character is '{' do indent, without
@ -1838,7 +1838,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
// stuff onto the replace stack (via ins_char()).
if (State & VREPLACE_FLAG) {
// Put new line in p_extra
p_extra = (char *)vim_strsave(get_cursor_line_ptr());
p_extra = xstrdup(get_cursor_line_ptr());
// Put back original line
ml_replace(curwin->w_cursor.lnum, next_line, false);

54
src/nvim/charset.c
View File

@ -789,7 +789,7 @@ bool vim_iswordc_buf(const int c, buf_T *const buf)
bool vim_iswordp(const char_u *const p)
FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
{
return vim_iswordp_buf(p, curbuf);
return vim_iswordp_buf((char *)p, curbuf);
}
/// Just like vim_iswordc_buf() but uses a pointer to the (multi-byte)
@ -799,13 +799,13 @@ bool vim_iswordp(const char_u *const p)
/// @param buf buffer whose keywords to use
///
/// @return true if "p" points to a keyword character.
bool vim_iswordp_buf(const char_u *const p, buf_T *const buf)
bool vim_iswordp_buf(const char *const p, buf_T *const buf)
FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
{
int c = *p;
int c = (uint8_t)(*p);
if (MB_BYTE2LEN(c) > 1) {
c = utf_ptr2char((char *)p);
c = utf_ptr2char(p);
}
return vim_iswordc_buf(c, buf);
}
@ -829,8 +829,8 @@ bool vim_isfilec(int c)
bool vim_isfilec_or_wc(int c)
FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
{
char_u buf[2];
buf[0] = (char_u)c;
char buf[2];
buf[0] = (char)c;
buf[1] = NUL;
return vim_isfilec(c) || c == ']' || path_has_wildcard(buf);
}
@ -905,15 +905,15 @@ bool in_win_border(win_T *wp, colnr_T vcol)
/// @param end
void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *end)
{
char_u *ptr; // points to current char
char_u *posptr; // points to char at pos->col
char *ptr; // points to current char
char *posptr; // points to char at pos->col
int incr;
int head;
long *vts = wp->w_buffer->b_p_vts_array;
int ts = (int)wp->w_buffer->b_p_ts;
colnr_T vcol = 0;
char_u *line = ptr = ml_get_buf(wp->w_buffer, pos->lnum, false); // start of the line
char *line = ptr = (char *)ml_get_buf(wp->w_buffer, pos->lnum, false); // start of the line
if (pos->col == MAXCOL) {
// continue until the NUL
@ -927,11 +927,11 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
}
}
posptr = ptr + pos->col;
posptr -= utf_head_off((char *)line, (char *)posptr);
posptr -= utf_head_off(line, posptr);
}
chartabsize_T cts;
init_chartabsize_arg(&cts, wp, pos->lnum, 0, (char *)line, (char *)line);
init_chartabsize_arg(&cts, wp, pos->lnum, 0, line, line);
// This function is used very often, do some speed optimizations.
// When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
@ -944,7 +944,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
&& !cts.cts_has_virt_text) {
for (;;) {
head = 0;
int c = *ptr;
int c = (uint8_t)(*ptr);
// make sure we don't go past the end of the line
if (c == NUL) {
@ -960,7 +960,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
// For utf-8, if the byte is >= 0x80, need to look at
// further bytes to find the cell width.
if (c >= 0x80) {
incr = utf_ptr2cells((char *)ptr);
incr = utf_ptr2cells(ptr);
} else {
incr = g_chartab[c] & CT_CELL_MASK;
}
@ -970,7 +970,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
// cells wide.
if ((incr == 2)
&& wp->w_p_wrap
&& (MB_BYTE2LEN(*ptr) > 1)
&& (MB_BYTE2LEN((uint8_t)(*ptr)) > 1)
&& in_win_border(wp, vcol)) {
incr++;
head = 1;
@ -999,7 +999,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
break;
}
if ((posptr != NULL) && ((char_u *)cts.cts_ptr >= posptr)) {
if ((posptr != NULL) && (cts.cts_ptr >= posptr)) {
// character at pos->col
break;
}
@ -1008,7 +1008,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
MB_PTR_ADV(cts.cts_ptr);
}
vcol = cts.cts_vcol;
ptr = (char_u *)cts.cts_ptr;
ptr = cts.cts_ptr;
}
clear_chartabsize_arg(&cts);
@ -1076,10 +1076,10 @@ void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *e
colnr_T endadd = 0;
// Cannot put the cursor on part of a wide character.
char_u *ptr = ml_get_buf(wp->w_buffer, pos->lnum, false);
char *ptr = (char *)ml_get_buf(wp->w_buffer, pos->lnum, false);
if (pos->col < (colnr_T)STRLEN(ptr)) {
int c = utf_ptr2char((char *)ptr + pos->col);
int c = utf_ptr2char(ptr + pos->col);
if ((c != TAB) && vim_isprintc(c)) {
endadd = (colnr_T)(char2cells(c) - 1);
if (coladd > endadd) {
@ -1182,7 +1182,7 @@ char *skipwhite_len(const char *p, size_t len)
// columns (bytes) at the start of a given line
intptr_t getwhitecols_curline(void)
{
return getwhitecols((char *)get_cursor_line_ptr());
return getwhitecols(get_cursor_line_ptr());
}
intptr_t getwhitecols(const char *p)
@ -1338,7 +1338,7 @@ char *skip_to_newline(const char *const p)
/// Gets a number from a string and skips over it, signalling overflow.
///
/// @param[out] pp A pointer to a pointer to char_u.
/// @param[out] pp A pointer to a pointer to char.
/// It will be advanced past the read number.
/// @param[out] nr Number read from the string.
///
@ -1355,7 +1355,7 @@ bool try_getdigits(char **pp, intmax_t *nr)
/// Gets a number from a string and skips over it.
///
/// @param[out] pp Pointer to a pointer to char_u.
/// @param[out] pp Pointer to a pointer to char.
/// It will be advanced past the read number.
/// @param strict Abort on overflow.
/// @param def Default value, if parsing fails or overflow occurs.
@ -1463,14 +1463,14 @@ bool vim_isblankline(char *lbuf)
/// @param strict If true, fail if the number has unexpected trailing
/// alphanumeric chars: *len is set to 0 and nothing else is
/// returned.
void vim_str2nr(const char_u *const start, int *const prep, int *const len, const int what,
void vim_str2nr(const char *const start, int *const prep, int *const len, const int what,
varnumber_T *const nptr, uvarnumber_T *const unptr, const int maxlen,
const bool strict)
FUNC_ATTR_NONNULL_ARG(1)
{
const char *ptr = (const char *)start;
const char *ptr = start;
#define STRING_ENDED(ptr) \
(!(maxlen == 0 || (int)((ptr) - (const char *)start) < maxlen))
(!(maxlen == 0 || (int)((ptr) - start) < maxlen))
int pre = 0; // default is decimal
const bool negative = (ptr[0] == '-');
uvarnumber_T un = 0;
@ -1522,7 +1522,7 @@ void vim_str2nr(const char_u *const start, int *const prep, int *const len, cons
} else if ((what & (STR2NR_HEX | STR2NR_OCT | STR2NR_OOCT | STR2NR_BIN))
&& !STRING_ENDED(ptr + 1) && ptr[0] == '0' && ptr[1] != '8'
&& ptr[1] != '9') {
pre = (char_u)ptr[1];
pre = (uint8_t)ptr[1];
// Detect hexadecimal: 0x or 0X followed by hex digit.
if ((what & STR2NR_HEX)
&& !STRING_ENDED(ptr + 2)
@ -1610,7 +1610,7 @@ vim_str2nr_hex:
vim_str2nr_proceed:
// Check for an alphanumeric character immediately following, that is
// most likely a typo.
if (strict && ptr - (const char *)start != maxlen && ASCII_ISALNUM(*ptr)) {
if (strict && ptr - start != maxlen && ASCII_ISALNUM(*ptr)) {
return;
}
@ -1619,7 +1619,7 @@ vim_str2nr_proceed:
}
if (len != NULL) {
*len = (int)(ptr - (const char *)start);
*len = (int)(ptr - start);
}
if (nptr != NULL) {

69
src/nvim/cmdexpand.c
View File

@ -177,7 +177,7 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
ui_flush();
}
i = (int)((char_u *)xp->xp_pattern - ccline->cmdbuff);
i = (int)(xp->xp_pattern - ccline->cmdbuff);
assert(ccline->cmdpos >= i);
xp->xp_pattern_len = (size_t)ccline->cmdpos - (size_t)i;
@ -186,20 +186,20 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
p2 = ExpandOne(xp, NULL, NULL, 0, type);
} else {
// Translate string into pattern and expand it.
p1 = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
p1 = (char_u *)addstar(xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
const int use_options = (options
| WILD_HOME_REPLACE
| WILD_ADD_SLASH
| WILD_SILENT
| (escape ? WILD_ESCAPE : 0)
| (p_wic ? WILD_ICASE : 0));
p2 = ExpandOne(xp, p1, vim_strnsave(&ccline->cmdbuff[i], xp->xp_pattern_len),
p2 = ExpandOne(xp, p1, (char_u *)xstrnsave(&ccline->cmdbuff[i], xp->xp_pattern_len),
use_options, type);
xfree(p1);
// xp->xp_pattern might have been modified by ExpandOne (for example,
// in lua completion), so recompute the pattern index and length
i = (int)((char_u *)xp->xp_pattern - ccline->cmdbuff);
i = (int)(xp->xp_pattern - ccline->cmdbuff);
xp->xp_pattern_len = (size_t)ccline->cmdpos - (size_t)i;
// Longest match: make sure it is not shorter, happens with :help.
@ -220,7 +220,7 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
difflen = (int)STRLEN(p2) - (int)(xp->xp_pattern_len);
if (ccline->cmdlen + difflen + 4 > ccline->cmdbufflen) {
realloc_cmdbuff(ccline->cmdlen + difflen + 4);
xp->xp_pattern = (char *)ccline->cmdbuff + i;
xp->xp_pattern = ccline->cmdbuff + i;
}
assert(ccline->cmdpos <= ccline->cmdlen);
memmove(&ccline->cmdbuff[ccline->cmdpos + difflen],
@ -573,7 +573,7 @@ int showmatches(expand_T *xp, int wildmenu)
if (xp->xp_numfiles == -1) {
set_expand_context(xp);
i = expand_cmdline(xp, ccline->cmdbuff, ccline->cmdpos,
i = expand_cmdline(xp, (char_u *)ccline->cmdbuff, ccline->cmdpos,
&num_files, &files_found);
showtail = expand_showtail(xp);
if (i != EXPAND_OK) {
@ -602,7 +602,7 @@ int showmatches(expand_T *xp, int wildmenu)
.pum_kind = NULL,
};
}
char_u *endpos = (char_u *)(showtail ? sm_gettail(xp->xp_pattern, true) : xp->xp_pattern);
char *endpos = (showtail ? sm_gettail(xp->xp_pattern, true) : xp->xp_pattern);
if (ui_has(kUICmdline)) {
compl_startcol = (int)(endpos - ccline->cmdbuff);
} else {
@ -803,13 +803,13 @@ static bool expand_showtail(expand_T *xp)
/// the name into allocated memory and prepend "^".
///
/// @param context EXPAND_FILES etc.
char_u *addstar(char_u *fname, size_t len, int context)
char *addstar(char *fname, size_t len, int context)
FUNC_ATTR_NONNULL_RET
{
char_u *retval;
char *retval;
size_t i, j;
size_t new_len;
char_u *tail;
char *tail;
int ends_in_star;
if (context != EXPAND_FILES
@ -831,7 +831,7 @@ char_u *addstar(char_u *fname, size_t len, int context)
|| context == EXPAND_PACKADD
|| ((context == EXPAND_TAGS_LISTFILES || context == EXPAND_TAGS)
&& fname[0] == '/')) {
retval = vim_strnsave(fname, len);
retval = xstrnsave(fname, len);
} else {
new_len = len + 2; // +2 for '^' at start, NUL at end
for (i = 0; i < len; i++) {
@ -901,7 +901,7 @@ char_u *addstar(char_u *fname, size_t len, int context)
// $ could be anywhere in the tail.
// ` could be anywhere in the file name.
// When the name ends in '$' don't add a star, remove the '$'.
tail = (char_u *)path_tail((char *)retval);
tail = path_tail(retval);
ends_in_star = (len > 0 && retval[len - 1] == '*');
#ifndef BACKSLASH_IN_FILENAME
for (ssize_t k = (ssize_t)len - 2; k >= 0; k--) {
@ -913,8 +913,8 @@ char_u *addstar(char_u *fname, size_t len, int context)
#endif
if ((*retval != '~' || tail != retval)
&& !ends_in_star
&& vim_strchr((char *)tail, '$') == NULL
&& vim_strchr((char *)retval, '`') == NULL) {
&& vim_strchr(tail, '$') == NULL
&& vim_strchr(retval, '`') == NULL) {
retval[len++] = '*';
} else if (len > 0 && retval[len - 1] == '$') {
len--;
@ -976,7 +976,7 @@ void set_expand_context(expand_T *xp)
xp->xp_context = EXPAND_NOTHING;
return;
}
set_cmd_context(xp, ccline->cmdbuff, ccline->cmdlen, ccline->cmdpos, true);
set_cmd_context(xp, (char_u *)ccline->cmdbuff, ccline->cmdlen, ccline->cmdpos, true);
}
/// Sets the index of a built-in or user defined command "cmd" in eap->cmdidx.
@ -1851,7 +1851,7 @@ void set_cmd_context(expand_T *xp, char_u *str, int len, int col, int use_ccline
set_context_for_expression(xp, (char *)str, CMD_SIZE);
} else if (use_ccline && ccline->input_fn) {
xp->xp_context = ccline->xp_context;
xp->xp_pattern = (char *)ccline->cmdbuff;
xp->xp_pattern = ccline->cmdbuff;
xp->xp_arg = (char *)ccline->xp_arg;
} else {
while (nextcomm != NULL) {
@ -1898,7 +1898,7 @@ int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount, char ***
// add star to file name, or convert to regexp if not exp. files.
assert((str + col) - (char_u *)xp->xp_pattern >= 0);
xp->xp_pattern_len = (size_t)((str + col) - (char_u *)xp->xp_pattern);
file_str = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
file_str = (char_u *)addstar(xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
if (p_wic) {
options += WILD_ICASE;
@ -2438,9 +2438,9 @@ static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T
FUNC_ATTR_NONNULL_ALL
{
CmdlineInfo *const ccline = get_cmdline_info();
char_u keep = 0;
char keep = 0;
typval_T args[4];
char_u *pat = NULL;
char *pat = NULL;
const sctx_T save_current_sctx = current_sctx;
if (xp->xp_arg == NULL || xp->xp_arg[0] == '\0' || xp->xp_line == NULL) {
@ -2454,12 +2454,12 @@ static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T
ccline->cmdbuff[ccline->cmdlen] = 0;
}
pat = vim_strnsave((char_u *)xp->xp_pattern, xp->xp_pattern_len);
pat = xstrnsave(xp->xp_pattern, xp->xp_pattern_len);
args[0].v_type = VAR_STRING;
args[1].v_type = VAR_STRING;
args[2].v_type = VAR_NUMBER;
args[3].v_type = VAR_UNKNOWN;
args[0].vval.v_string = (char *)pat;
args[0].vval.v_string = pat;
args[1].vval.v_string = xp->xp_line;
args[2].vval.v_number = xp->xp_col;
@ -2479,10 +2479,10 @@ static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T
/// Expand names with a function defined by the user.
static int ExpandUserDefined(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***file)
{
char_u *e;
char *e;
garray_T ga;
char_u *const retstr = call_user_expand_func((user_expand_func_T)call_func_retstr, xp, num_file,
char *const retstr = call_user_expand_func((user_expand_func_T)call_func_retstr, xp, num_file,
file);
if (retstr == NULL) {
@ -2490,19 +2490,18 @@ static int ExpandUserDefined(expand_T *xp, regmatch_T *regmatch, int *num_file,
}
ga_init(&ga, (int)sizeof(char *), 3);
for (char_u *s = retstr; *s != NUL; s = e) {
e = (char_u *)vim_strchr((char *)s, '\n');
for (char *s = retstr; *s != NUL; s = e) {
e = vim_strchr(s, '\n');
if (e == NULL) {
e = s + STRLEN(s);
}
const char_u keep = *e;
const char keep = *e;
*e = NUL;
const bool skip = xp->xp_pattern[0]
&& vim_regexec(regmatch, (char *)s, (colnr_T)0) == 0;
const bool skip = xp->xp_pattern[0] && vim_regexec(regmatch, s, (colnr_T)0) == 0;
*e = keep;
if (!skip) {
GA_APPEND(char_u *, &ga, vim_strnsave(s, (size_t)(e - s)));
GA_APPEND(char *, &ga, xstrnsave(s, (size_t)(e - s)));
}
if (*e != NUL) {
@ -2663,7 +2662,7 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
// cursor
int found = false;
int j = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
int j = (int)(xp->xp_pattern - cclp->cmdbuff);
int i = 0;
while (--j > 0) {
// check for start of menu name
@ -2718,9 +2717,9 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
int found = false;
int j = cclp->cmdpos;
int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
int i = (int)(xp->xp_pattern - cclp->cmdbuff);
while (--j > i) {
j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
if (vim_ispathsep(cclp->cmdbuff[j])) {
found = true;
break;
@ -2739,9 +2738,9 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
int found = false;
int j = cclp->cmdpos - 1;
int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
int i = (int)(xp->xp_pattern - cclp->cmdbuff);
while (--j > i) {
j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
if (vim_ispathsep(cclp->cmdbuff[j])
#ifdef BACKSLASH_IN_FILENAME
&& vim_strchr((const char_u *)" *?[{`$%#", cclp->cmdbuff[j + 1])
@ -2895,7 +2894,7 @@ void f_getcompletion(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
}
theend:
pat = addstar((char_u *)xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
pat = (char_u *)addstar(xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
ExpandOne(&xpc, pat, NULL, options, WILD_ALL_KEEP);
tv_list_alloc_ret(rettv, xpc.xp_numfiles);

24
src/nvim/cmdhist.c
View File

@ -201,7 +201,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
// For search history, check that the separator character matches as
// well.
char_u *p = history[type][i].hisstr;
char_u *p = (char_u *)history[type][i].hisstr;
if (STRCMP(str, p) == 0
&& (type != HIST_SEARCH || sep == p[STRLEN(p) + 1])) {
if (!move_to_front) {
@ -217,7 +217,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
if (last_i >= 0) {
list_T *const list = history[type][i].additional_elements;
str = history[type][i].hisstr;
str = (char_u *)history[type][i].hisstr;
while (i != hisidx[type]) {
if (++i >= hislen) {
i = 0;
@ -227,7 +227,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
}
tv_list_unref(list);
history[type][i].hisnum = ++hisnum[type];
history[type][i].hisstr = str;
history[type][i].hisstr = (char *)str;
history[type][i].timestamp = os_time();
history[type][i].additional_elements = NULL;
return true;
@ -276,7 +276,7 @@ static int last_maptick = -1; // last seen maptick
/// @param histype may be one of the HIST_ values.
/// @param in_map consider maptick when inside a mapping
/// @param sep separator character used (search hist)
void add_to_history(int histype, char_u *new_entry, int in_map, int sep)
void add_to_history(int histype, char *new_entry, int in_map, int sep)
{
histentry_T *hisptr;
@ -304,7 +304,7 @@ void add_to_history(int histype, char_u *new_entry, int in_map, int sep)
}
last_maptick = -1;
}
if (!in_history(histype, new_entry, true, sep)) {
if (!in_history(histype, (char_u *)new_entry, true, sep)) {
if (++hisidx[histype] == hislen) {
hisidx[histype] = 0;
}
@ -313,10 +313,10 @@ void add_to_history(int histype, char_u *new_entry, int in_map, int sep)
// Store the separator after the NUL of the string.
size_t len = STRLEN(new_entry);
hisptr->hisstr = vim_strnsave(new_entry, len + 2);
hisptr->hisstr = xstrnsave(new_entry, len + 2);
hisptr->timestamp = os_time();
hisptr->additional_elements = NULL;
hisptr->hisstr[len + 1] = (char_u)sep;
hisptr->hisstr[len + 1] = (char)sep;
hisptr->hisnum = ++hisnum[histype];
if (histype == HIST_SEARCH && in_map) {
@ -386,7 +386,7 @@ static char_u *get_history_entry(int histype, int idx)
{
idx = calc_hist_idx(histype, idx);
if (idx >= 0) {
return history[histype][idx].hisstr;
return (char_u *)history[histype][idx].hisstr;
} else {
return (char_u *)"";
}
@ -438,7 +438,7 @@ static int del_history_entry(int histype, char_u *str)
if (hisptr->hisstr == NULL) {
break;
}
if (vim_regexec(&regmatch, (char *)hisptr->hisstr, (colnr_T)0)) {
if (vim_regexec(&regmatch, hisptr->hisstr, (colnr_T)0)) {
found = true;
hist_free_entry(hisptr);
} else {
@ -509,7 +509,7 @@ void f_histadd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
str = tv_get_string_buf(&argvars[1], buf);
if (*str != NUL) {
init_history();
add_to_history(histype, (char_u *)str, false, NUL);
add_to_history(histype, (char *)str, false, NUL);
rettv->vval.v_number = true;
return;
}
@ -643,8 +643,8 @@ void ex_history(exarg_T *eap)
msg_putchar('\n');
snprintf((char *)IObuff, IOSIZE, "%c%6d ", i == idx ? '>' : ' ',
hist[i].hisnum);
if (vim_strsize((char *)hist[i].hisstr) > Columns - 10) {
trunc_string((char *)hist[i].hisstr, (char *)IObuff + STRLEN(IObuff),
if (vim_strsize(hist[i].hisstr) > Columns - 10) {
trunc_string(hist[i].hisstr, (char *)IObuff + STRLEN(IObuff),
Columns - 10, IOSIZE - (int)STRLEN(IObuff));
} else {
STRCAT(IObuff, hist[i].hisstr);

2
src/nvim/cmdhist.h
View File

@ -22,7 +22,7 @@ typedef enum {
/// History entry definition
typedef struct hist_entry {
int hisnum; ///< Entry identifier number.
char_u *hisstr; ///< Actual entry, separator char after the NUL.
char *hisstr; ///< Actual entry, separator char after the NUL.
Timestamp timestamp; ///< Time when entry was added.
list_T *additional_elements; ///< Additional entries from ShaDa file.
} histentry_T;

4
src/nvim/cursor.c
View File

@ -493,9 +493,9 @@ void pchar_cursor(char_u c)
}
/// @return pointer to cursor line.
char_u *get_cursor_line_ptr(void)
char *get_cursor_line_ptr(void)
{
return ml_get_buf(curbuf, curwin->w_cursor.lnum, false);
return (char *)ml_get_buf(curbuf, curwin->w_cursor.lnum, false);
}
/// @return pointer to cursor position.

24
src/nvim/digraph.c
View File

@ -2010,8 +2010,8 @@ void f_digraph_setlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
/// structure used for b_kmap_ga.ga_data
typedef struct {
char_u *from;
char_u *to;
char *from;
char *to;
} kmap_T;
#define KMAP_MAXLEN 20 // maximum length of "from" or "to"
@ -2064,10 +2064,10 @@ char *keymap_init(void)
/// @param eap
void ex_loadkeymap(exarg_T *eap)
{
char_u *s;
char *s;
#define KMAP_LLEN 200 // max length of "to" and "from" together
char_u buf[KMAP_LLEN + 11];
char buf[KMAP_LLEN + 11];
char *save_cpo = p_cpo;
if (!getline_equal(eap->getline, eap->cookie, getsourceline)) {
@ -2092,15 +2092,15 @@ void ex_loadkeymap(exarg_T *eap)
break;
}
char_u *p = (char_u *)skipwhite(line);
char *p = skipwhite(line);
if ((*p != '"') && (*p != NUL)) {
kmap_T *kp = GA_APPEND_VIA_PTR(kmap_T, &curbuf->b_kmap_ga);
s = (char_u *)skiptowhite((char *)p);
kp->from = vim_strnsave(p, (size_t)(s - p));
p = (char_u *)skipwhite((char *)s);
s = (char_u *)skiptowhite((char *)p);
kp->to = vim_strnsave(p, (size_t)(s - p));
s = skiptowhite(p);
kp->from = xstrnsave(p, (size_t)(s - p));
p = skipwhite(s);
s = skiptowhite(p);
kp->to = xstrnsave(p, (size_t)(s - p));
if ((STRLEN(kp->from) + STRLEN(kp->to) >= KMAP_LLEN)
|| (*kp->from == NUL)
@ -2118,10 +2118,10 @@ void ex_loadkeymap(exarg_T *eap)
// setup ":lmap" to map the keys
for (int i = 0; i < curbuf->b_kmap_ga.ga_len; i++) {
vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s %s",
vim_snprintf(buf, sizeof(buf), "<buffer> %s %s",
((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].from,
((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].to);
(void)do_map(MAPTYPE_MAP, buf, MODE_LANGMAP, false);
(void)do_map(MAPTYPE_MAP, (char_u *)buf, MODE_LANGMAP, false);
}
p_cpo = save_cpo;

36
src/nvim/edit.c
View File

@ -190,7 +190,7 @@ static void insert_enter(InsertState *s)
}
}
Insstart_textlen = (colnr_T)linetabsize(get_cursor_line_ptr());
Insstart_textlen = (colnr_T)linetabsize((char_u *)get_cursor_line_ptr());
Insstart_blank_vcol = MAXCOL;
if (!did_ai) {
@ -274,7 +274,7 @@ static void insert_enter(InsertState *s)
update_curswant();
if (((ins_at_eol && curwin->w_cursor.lnum == o_lnum)
|| curwin->w_curswant > curwin->w_virtcol)
&& *(s->ptr = get_cursor_line_ptr() + curwin->w_cursor.col) != NUL) {
&& *(s->ptr = (char_u *)get_cursor_line_ptr() + curwin->w_cursor.col) != NUL) {
if (s->ptr[1] == NUL) {
curwin->w_cursor.col++;
} else {
@ -1470,7 +1470,7 @@ static void init_prompt(int cmdchar_todo)
char_u *text;
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
text = get_cursor_line_ptr();
text = (char_u *)get_cursor_line_ptr();
if (STRNCMP(text, prompt, STRLEN(prompt)) != 0) {
// prompt is missing, insert it or append a line with it
if (*text == NUL) {
@ -1544,7 +1544,7 @@ void display_dollar(colnr_T col)
curwin->w_cursor.col = col;
// If on the last byte of a multi-byte move to the first byte.
char_u *p = get_cursor_line_ptr();
char_u *p = (char_u *)get_cursor_line_ptr();
curwin->w_cursor.col -= utf_head_off((char *)p, (char *)p + col);
curs_columns(curwin, false); // Recompute w_wrow and w_wcol
if (curwin->w_wcol < curwin->w_grid.cols) {
@ -1590,7 +1590,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
// MODE_VREPLACE state needs to know what the line was like before changing
if (State & VREPLACE_FLAG) {
orig_line = vim_strsave(get_cursor_line_ptr()); // Deal with NULL below
orig_line = vim_strsave((char_u *)get_cursor_line_ptr()); // Deal with NULL below
orig_col = curwin->w_cursor.col;
}
@ -1670,7 +1670,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
// Advance the cursor until we reach the right screen column.
last_vcol = 0;
ptr = get_cursor_line_ptr();
ptr = (char_u *)get_cursor_line_ptr();
chartabsize_T cts;
init_chartabsize_arg(&cts, curwin, 0, 0, (char *)ptr, (char *)ptr);
while (cts.cts_vcol <= (int)curwin->w_virtcol) {
@ -1761,7 +1761,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
// then put it back again the way we wanted it.
if (State & VREPLACE_FLAG) {
// Save new line
new_line = vim_strsave(get_cursor_line_ptr());
new_line = vim_strsave((char_u *)get_cursor_line_ptr());
// We only put back the new line up to the cursor
new_line[curwin->w_cursor.col] = NUL;
@ -2082,7 +2082,7 @@ void insertchar(int c, int flags, int second_indent)
// Need to remove existing (middle) comment leader and insert end
// comment leader. First, check what comment leader we can find.
char_u *line = get_cursor_line_ptr();
char_u *line = (char_u *)get_cursor_line_ptr();
int i = get_leader_len((char *)line, &p, false, true);
if (i > 0 && vim_strchr(p, COM_MIDDLE) != NULL) { // Just checking
// Skip middle-comment string
@ -2287,7 +2287,7 @@ int stop_arrow(void)
// right, except when nothing was inserted yet.
update_Insstart_orig = false;
}
Insstart_textlen = (colnr_T)linetabsize(get_cursor_line_ptr());
Insstart_textlen = (colnr_T)linetabsize((char_u *)get_cursor_line_ptr());
if (u_save_cursor() == OK) {
arrow_used = false;
@ -2484,7 +2484,7 @@ void beginline(int flags)
if (flags & (BL_WHITE | BL_SOL)) {
char_u *ptr;
for (ptr = get_cursor_line_ptr(); ascii_iswhite(*ptr)
for (ptr = (char_u *)get_cursor_line_ptr(); ascii_iswhite(*ptr)
&& !((flags & BL_FIX) && ptr[1] == NUL); ptr++) {
curwin->w_cursor.col++;
}
@ -2799,7 +2799,7 @@ static bool echeck_abbr(int c)
return false;
}
return check_abbr(c, get_cursor_line_ptr(), curwin->w_cursor.col,
return check_abbr(c, (char_u *)get_cursor_line_ptr(), curwin->w_cursor.col,
curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0);
}
@ -3148,7 +3148,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
// cursor.
} else if (*look == 'e') {
if (try_match && keytyped == 'e' && curwin->w_cursor.col >= 4) {
p = get_cursor_line_ptr();
p = (char_u *)get_cursor_line_ptr();
if ((char_u *)skipwhite((char *)p) == p + curwin->w_cursor.col - 4
&& STRNCMP(p + curwin->w_cursor.col - 4, "else", 4) == 0) {
return true;
@ -3161,12 +3161,12 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
// class::method for C++).
} else if (*look == ':') {
if (try_match && keytyped == ':') {
p = get_cursor_line_ptr();
p = (char_u *)get_cursor_line_ptr();
if (cin_iscase(p, false) || cin_isscopedecl(p) || cin_islabel()) {
return true;
}
// Need to get the line again after cin_islabel().
p = get_cursor_line_ptr();
p = (char_u *)get_cursor_line_ptr();
if (curwin->w_cursor.col > 2
&& p[curwin->w_cursor.col - 1] == ':'
&& p[curwin->w_cursor.col - 2] == ':') {
@ -3174,7 +3174,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
const bool i = cin_iscase(p, false)
|| cin_isscopedecl(p)
|| cin_islabel();
p = get_cursor_line_ptr();
p = (char_u *)get_cursor_line_ptr();
p[curwin->w_cursor.col - 1] = ':';
if (i) {
return true;
@ -3226,7 +3226,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
/* Just completed a word, check if it starts with "look".
* search back for the start of a word. */
line = get_cursor_line_ptr();
line = (char_u *)get_cursor_line_ptr();
for (s = line + curwin->w_cursor.col; s > line; s = n) {
n = mb_prevptr(line, s);
if (!vim_iswordp(n)) {
@ -3805,7 +3805,7 @@ static void ins_shift(int c, int lastc)
change_indent(c == Ctrl_D ? INDENT_DEC : INDENT_INC, 0, true, 0, true);
}
if (did_ai && *skipwhite((char *)get_cursor_line_ptr()) != NUL) {
if (did_ai && *skipwhite(get_cursor_line_ptr()) != NUL) {
did_ai = false;
}
did_si = false;
@ -4609,7 +4609,7 @@ static bool ins_tab(void)
if (State & VREPLACE_FLAG) {
pos = curwin->w_cursor;
cursor = &pos;
saved_line = vim_strsave(get_cursor_line_ptr());
saved_line = vim_strsave((char_u *)get_cursor_line_ptr());
ptr = saved_line + pos.col;
} else {
ptr = get_cursor_pos_ptr();

4
src/nvim/eval.c
View File

@ -2995,7 +2995,7 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
*arg = bp;
} else {
// decimal, hex or octal number
vim_str2nr((char_u *)(*arg), NULL, &len, STR2NR_ALL, &n, NULL, 0, true);
vim_str2nr(*arg, NULL, &len, STR2NR_ALL, &n, NULL, 0, true);
if (len == 0) {
semsg(_(e_invexpr2), *arg);
ret = FAIL;
@ -6450,7 +6450,7 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
} else {
pos.lnum = curwin->w_cursor.lnum;
if (charcol) {
pos.col = (colnr_T)mb_charlen(get_cursor_line_ptr());
pos.col = (colnr_T)mb_charlen((char_u *)get_cursor_line_ptr());
} else {
pos.col = (colnr_T)STRLEN(get_cursor_line_ptr());
}

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

@ -430,7 +430,7 @@ static inline int parse_json_string(const char *const buf, const size_t buf_len,
const char ubuf[] = { t[1], t[2], t[3], t[4] };
t += 4;
uvarnumber_T ch;
vim_str2nr((char_u *)ubuf, NULL, NULL,
vim_str2nr(ubuf, NULL, NULL,
STR2NR_HEX | STR2NR_FORCE, NULL, &ch, 4, true);
if (ch == 0) {
hasnul = true;
@ -600,7 +600,7 @@ parse_json_number_check:
// Convert integer
varnumber_T nr;
int num_len;
vim_str2nr((char_u *)s, NULL, &num_len, 0, &nr, NULL, (int)(p - s), true);
vim_str2nr(s, NULL, &num_len, 0, &nr, NULL, (int)(p - s), true);
if ((int)exp_num_len != num_len) {
semsg(_("E685: internal error: while converting number \"%.*s\" "
"to integer vim_str2nr consumed %i bytes in place of %zu"),

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

@ -5869,9 +5869,9 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
bool binary = false;
bool blob = false;
FILE *fd;
char_u buf[(IOSIZE/256) * 256]; // rounded to avoid odd + 1
char buf[(IOSIZE/256) * 256]; // rounded to avoid odd + 1
int io_size = sizeof(buf);
char_u *prev = NULL; // previously read bytes, if any
char *prev = NULL; // previously read bytes, if any
long prevlen = 0; // length of data in prev
long prevsize = 0; // size of prev buffer
long maxline = MAXLNUM;
@ -5922,13 +5922,13 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
// - an incomplete line gets written
// - a "binary" file gets an empty line at the end if it ends in a
// newline.
char_u *p; // Position in buf.
char_u *start; // Start of current line.
char *p; // Position in buf.
char *start; // Start of current line.
for (p = buf, start = buf;
p < buf + readlen || (readlen <= 0 && (prevlen > 0 || binary));
p++) {
if (*p == '\n' || readlen <= 0) {
char_u *s = NULL;
char *s = NULL;
size_t len = (size_t)(p - start);
// Finished a line. Remove CRs before NL.
@ -5945,7 +5945,7 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
}
if (prevlen == 0) {
assert(len < INT_MAX);
s = vim_strnsave(start, len);
s = xstrnsave(start, len);
} else {
// Change "prev" buffer to be the right size. This way
// the bytes are only copied once, and very long lines are
@ -5960,7 +5960,7 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
tv_list_append_owned_tv(l, (typval_T) {
.v_type = VAR_STRING,
.v_lock = VAR_UNLOCKED,
.vval.v_string = (char *)s,
.vval.v_string = s,
});
start = p + 1; // Step over newline.
@ -5980,18 +5980,18 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
*p = '\n';
// Check for utf8 "bom"; U+FEFF is encoded as EF BB BF. Do this
// when finding the BF and check the previous two bytes.
} else if (*p == 0xbf && !binary) {
} else if ((uint8_t)(*p) == 0xbf && !binary) {
// Find the two bytes before the 0xbf. If p is at buf, or buf + 1,
// these may be in the "prev" string.
char_u back1 = p >= buf + 1 ? p[-1]
char back1 = p >= buf + 1 ? p[-1]
: prevlen >= 1 ? prev[prevlen - 1] : NUL;
char_u back2 = p >= buf + 2 ? p[-2]
char back2 = p >= buf + 2 ? p[-2]
: p == buf + 1 && prevlen >= 1 ? prev[prevlen - 1]
: prevlen >=
2 ? prev[prevlen - 2] : NUL;
if (back2 == 0xef && back1 == 0xbb) {
char_u *dest = p - 2;
if ((uint8_t)back2 == 0xef && (uint8_t)back1 == 0xbb) {
char *dest = p - 2;
// Usually a BOM is at the beginning of a file, and so at
// the beginning of a line; then we can just step over it.
@ -8304,7 +8304,7 @@ static void f_str2nr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
break;
}
varnumber_T n;
vim_str2nr(p, NULL, NULL, what, &n, NULL, 0, false);
vim_str2nr((char *)p, NULL, NULL, what, &n, NULL, 0, false);
// Text after the number is silently ignored.
if (isneg) {
rettv->vval.v_number = -n;
@ -9416,10 +9416,10 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
{
char buf1[NUMBUFLEN];
char buf2[NUMBUFLEN];
const char_u *head = (const char_u *)tv_get_string_buf_chk(&argvars[0], buf1);
const char_u *mask = NULL;
const char_u *prev;
const char_u *p;
const char *head = tv_get_string_buf_chk(&argvars[0], buf1);
const char *mask = NULL;
const char *prev;
const char *p;
int dir = 0;
rettv->v_type = VAR_STRING;
@ -9434,7 +9434,7 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
}
if (argvars[1].v_type == VAR_STRING) {
mask = (const char_u *)tv_get_string_buf_chk(&argvars[1], buf2);
mask = tv_get_string_buf_chk(&argvars[1], buf2);
if (argvars[2].v_type != VAR_UNKNOWN) {
bool error = false;
// leading or trailing characters to trim
@ -9472,7 +9472,7 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
}
}
const char_u *tail = head + STRLEN(head);
const char *tail = head + STRLEN(head);
if (dir == 0 || dir == 2) {
// Trim trailing characters
for (; tail > head; tail = prev) {
@ -9495,7 +9495,7 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
}
}
}
rettv->vval.v_string = (char *)vim_strnsave(head, (size_t)(tail - head));
rettv->vval.v_string = xstrnsave(head, (size_t)(tail - head));
}
/// "type(expr)" function

3
src/nvim/eval/typval.c
View File

@ -3717,8 +3717,7 @@ varnumber_T tv_get_number_chk(const typval_T *const tv, bool *const ret_error)
case VAR_STRING: {
varnumber_T n = 0;
if (tv->vval.v_string != NULL) {
vim_str2nr((char_u *)tv->vval.v_string, NULL, NULL, STR2NR_ALL, &n, NULL, 0,
false);
vim_str2nr(tv->vval.v_string, NULL, NULL, STR2NR_ALL, &n, NULL, 0, false);
}
return n;
}

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

@ -525,22 +525,22 @@ static inline bool eval_fname_sid(const char *const name)
///
/// @return transformed name: either `fname_buf` or a pointer to an allocated
/// memory.
static char_u *fname_trans_sid(const char_u *const name, char_u *const fname_buf,
char_u **const tofree, int *const error)
static char *fname_trans_sid(const char *const name, char *const fname_buf, char **const tofree,
int *const error)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
{
char_u *fname;
const int llen = eval_fname_script((const char *)name);
char *fname;
const int llen = eval_fname_script(name);
if (llen > 0) {
fname_buf[0] = K_SPECIAL;
fname_buf[1] = KS_EXTRA;
fname_buf[0] = (char)K_SPECIAL;
fname_buf[1] = (char)KS_EXTRA;
fname_buf[2] = KE_SNR;
int i = 3;
if (eval_fname_sid((const char *)name)) { // "<SID>" or "s:"
if (eval_fname_sid(name)) { // "<SID>" or "s:"
if (current_sctx.sc_sid <= 0) {
*error = ERROR_SCRIPT;
} else {
snprintf((char *)fname_buf + i, (size_t)(FLEN_FIXED + 1 - i), "%" PRId64 "_",
snprintf(fname_buf + i, (size_t)(FLEN_FIXED + 1 - i), "%" PRId64 "_",
(int64_t)current_sctx.sc_sid);
i = (int)STRLEN(fname_buf);
}
@ -555,7 +555,7 @@ static char_u *fname_trans_sid(const char_u *const name, char_u *const fname_buf
STRCPY(fname + i, name + llen);
}
} else {
fname = (char_u *)name;
fname = (char *)name;
}
return fname;
@ -1437,10 +1437,10 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
int ret = FAIL;
int error = ERROR_NONE;
ufunc_T *fp = NULL;
char_u fname_buf[FLEN_FIXED + 1];
char_u *tofree = NULL;
char_u *fname = NULL;
char_u *name = NULL;
char fname_buf[FLEN_FIXED + 1];
char *tofree = NULL;
char *fname = NULL;
char *name = NULL;
int argcount = argcount_in;
typval_T *argvars = argvars_in;
dict_T *selfdict = funcexe->selfdict;
@ -1463,8 +1463,8 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
if (fp == NULL) {
// Make a copy of the name, if it comes from a funcref variable it could
// be changed or deleted in the called function.
name = vim_strnsave((char_u *)funcname, (size_t)len);
fname = fname_trans_sid(name, fname_buf, &tofree, &error);
name = xstrnsave(funcname, (size_t)len);
fname = fname_trans_sid(name, (char *)fname_buf, &tofree, &error);
}
if (funcexe->doesrange != NULL) {
@ -1495,7 +1495,7 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
}
if (error == ERROR_NONE && funcexe->evaluate) {
char_u *rfname = fname;
char *rfname = fname;
// Ignore "g:" before a function name.
if (fp == NULL && fname[0] == 'g' && fname[1] == ':') {
@ -1519,21 +1519,21 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
} else if (fp != NULL || !builtin_function((const char *)rfname, -1)) {
// User defined function.
if (fp == NULL) {
fp = find_func(rfname);
fp = find_func((char_u *)rfname);
}
// Trigger FuncUndefined event, may load the function.
if (fp == NULL
&& apply_autocmds(EVENT_FUNCUNDEFINED, (char *)rfname, (char *)rfname, true, NULL)
&& apply_autocmds(EVENT_FUNCUNDEFINED, rfname, rfname, true, NULL)
&& !aborting()) {
// executed an autocommand, search for the function again
fp = find_func(rfname);
fp = find_func((char_u *)rfname);
}
// Try loading a package.
if (fp == NULL && script_autoload((const char *)rfname, STRLEN(rfname),
true) && !aborting()) {
// Loaded a package, search for the function again.
fp = find_func(rfname);
fp = find_func((char_u *)rfname);
}
if (fp != NULL && (fp->uf_flags & FC_DELETED)) {
@ -1570,11 +1570,11 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
} else if (funcexe->basetv != NULL) {
// expr->method(): Find the method name in the table, call its
// implementation with the base as one of the arguments.
error = call_internal_method(fname, argcount, argvars, rettv,
error = call_internal_method((char_u *)fname, argcount, argvars, rettv,
funcexe->basetv);
} else {
// Find the function name in the table, call its implementation.
error = call_internal_func(fname, argcount, argvars, rettv);
error = call_internal_func((char_u *)fname, argcount, argvars, rettv);
}
/*
* The function call (or "FuncUndefined" autocommand sequence) might
@ -1596,7 +1596,7 @@ theend:
// Report an error unless the argument evaluation or function call has been
// cancelled due to an aborting error, an interrupt, or an exception.
if (!aborting()) {
user_func_error(error, (name != NULL) ? name : (char_u *)funcname);
user_func_error(error, (name != NULL) ? (char_u *)name : (char_u *)funcname);
}
// clear the copies made from the partial
@ -1890,15 +1890,15 @@ theend:
/// ":function"
void ex_function(exarg_T *eap)
{
char_u *theline;
char_u *line_to_free = NULL;
char_u c;
char *theline;
char *line_to_free = NULL;
char c;
int saved_did_emsg;
bool saved_wait_return = need_wait_return;
char_u *name = NULL;
char_u *p;
char_u *arg;
char_u *line_arg = NULL;
char *name = NULL;
char *p;
char *arg;
char *line_arg = NULL;
garray_T newargs;
garray_T default_args;
garray_T newlines;
@ -1918,8 +1918,8 @@ void ex_function(exarg_T *eap)
linenr_T sourcing_lnum_off;
linenr_T sourcing_lnum_top;
bool is_heredoc = false;
char_u *skip_until = NULL;
char_u *heredoc_trimmed = NULL;
char *skip_until = NULL;
char *heredoc_trimmed = NULL;
bool show_block = false;
bool do_concat = true;
@ -1950,7 +1950,7 @@ void ex_function(exarg_T *eap)
* ":function /pat": list functions matching pattern.
*/
if (*eap->arg == '/') {
p = (char_u *)skip_regexp(eap->arg + 1, '/', true, NULL);
p = skip_regexp(eap->arg + 1, '/', true, NULL);
if (!eap->skip) {
regmatch_T regmatch;
@ -1978,7 +1978,7 @@ void ex_function(exarg_T *eap)
if (*p == '/') {
p++;
}
eap->nextcmd = check_nextcmd((char *)p);
eap->nextcmd = check_nextcmd(p);
return;
}
@ -1996,9 +1996,9 @@ void ex_function(exarg_T *eap)
// "fudi.fd_di" set, "fudi.fd_newkey" == NULL
// s:func script-local function name
// g:func global function name, same as "func"
p = (char_u *)eap->arg;
name = trans_function_name((char **)&p, eap->skip, TFN_NO_AUTOLOAD, &fudi, NULL);
paren = (vim_strchr((char *)p, '(') != NULL);
p = eap->arg;
name = (char *)trans_function_name(&p, eap->skip, TFN_NO_AUTOLOAD, &fudi, NULL);
paren = (vim_strchr(p, '(') != NULL);
if (name == NULL && (fudi.fd_dict == NULL || !paren) && !eap->skip) {
/*
* Return on an invalid expression in braces, unless the expression
@ -2028,16 +2028,16 @@ void ex_function(exarg_T *eap)
// - exclude line numbers from function body
//
if (!paren) {
if (!ends_excmd(*skipwhite((char *)p))) {
if (!ends_excmd(*skipwhite(p))) {
semsg(_(e_trailing_arg), p);
goto ret_free;
}
eap->nextcmd = check_nextcmd((char *)p);
eap->nextcmd = check_nextcmd(p);
if (eap->nextcmd != NULL) {
*p = NUL;
}
if (!eap->skip && !got_int) {
fp = find_func(name);
fp = find_func((char_u *)name);
if (fp != NULL) {
list_func_head(fp, !eap->forceit, eap->forceit);
for (int j = 0; j < fp->uf_lines.ga_len && !got_int; j++) {
@ -2063,7 +2063,7 @@ void ex_function(exarg_T *eap)
msg_puts(eap->forceit ? "endfunction" : " endfunction");
}
} else {
emsg_funcname(N_("E123: Undefined function: %s"), name);
emsg_funcname(N_("E123: Undefined function: %s"), (char_u *)name);
}
}
goto ret_free;
@ -2072,18 +2072,18 @@ void ex_function(exarg_T *eap)
/*
* ":function name(arg1, arg2)" Define function.
*/
p = (char_u *)skipwhite((char *)p);
p = skipwhite(p);
if (*p != '(') {
if (!eap->skip) {
semsg(_("E124: Missing '(': %s"), eap->arg);
goto ret_free;
}
// attempt to continue by skipping some text
if (vim_strchr((char *)p, '(') != NULL) {
p = (char_u *)vim_strchr((char *)p, '(');
if (vim_strchr(p, '(') != NULL) {
p = vim_strchr(p, '(');
}
}
p = (char_u *)skipwhite((char *)p + 1);
p = skipwhite(p + 1);
ga_init(&newargs, (int)sizeof(char_u *), 3);
ga_init(&newlines, (int)sizeof(char_u *), 3);
@ -2094,15 +2094,15 @@ void ex_function(exarg_T *eap)
if (name != NULL) {
arg = name;
} else {
arg = fudi.fd_newkey;
arg = (char *)fudi.fd_newkey;
}
if (arg != NULL && (fudi.fd_di == NULL || !tv_is_func(fudi.fd_di->di_tv))) {
int j = (*arg == K_SPECIAL) ? 3 : 0;
int j = ((uint8_t)(*arg) == K_SPECIAL) ? 3 : 0;
while (arg[j] != NUL && (j == 0 ? eval_isnamec1(arg[j]) : eval_isnamec(arg[j]))) {
j++;
}
if (arg[j] != NUL) {
emsg_funcname((char *)e_invarg2, arg);
emsg_funcname((char *)e_invarg2, (char_u *)arg);
}
}
// Disallow using the g: dict.
@ -2111,7 +2111,7 @@ void ex_function(exarg_T *eap)
}
}
if (get_function_args((char **)&p, ')', &newargs, &varargs,
if (get_function_args(&p, ')', &newargs, &varargs,
&default_args, eap->skip) == FAIL) {
goto errret_2;
}
@ -2123,7 +2123,7 @@ void ex_function(exarg_T *eap)
// find extra arguments "range", "dict", "abort" and "closure"
for (;;) {
p = (char_u *)skipwhite((char *)p);
p = skipwhite(p);
if (STRNCMP(p, "range", 5) == 0) {
flags |= FC_RANGE;
p += 5;
@ -2137,9 +2137,8 @@ void ex_function(exarg_T *eap)
flags |= FC_CLOSURE;
p += 7;
if (current_funccal == NULL) {
emsg_funcname(N_
("E932: Closure function should not be at top level: %s"),
name == NULL ? (char_u *)"" : name);
emsg_funcname(N_("E932: Closure function should not be at top level: %s"),
name == NULL ? (char_u *)"" : (char_u *)name);
goto erret;
}
} else {
@ -2165,8 +2164,8 @@ void ex_function(exarg_T *eap)
if (!eap->skip && !eap->forceit) {
if (fudi.fd_dict != NULL && fudi.fd_newkey == NULL) {
emsg(_(e_funcdict));
} else if (name != NULL && find_func(name) != NULL) {
emsg_funcname(e_funcexts, name);
} else if (name != NULL && find_func((char_u *)name) != NULL) {
emsg_funcname(e_funcexts, (char_u *)name);
}
}
@ -2195,7 +2194,7 @@ void ex_function(exarg_T *eap)
if (line_arg != NULL) {
// Use eap->arg, split up in parts by line breaks.
theline = line_arg;
p = (char_u *)vim_strchr((char *)theline, '\n');
p = vim_strchr(theline, '\n');
if (p == NULL) {
line_arg += STRLEN(line_arg);
} else {
@ -2205,9 +2204,9 @@ void ex_function(exarg_T *eap)
} else {
xfree(line_to_free);
if (eap->getline == NULL) {
theline = getcmdline(':', 0L, indent, do_concat);
theline = (char *)getcmdline(':', 0L, indent, do_concat);
} else {
theline = (char_u *)eap->getline(':', eap->cookie, indent, do_concat);
theline = eap->getline(':', eap->cookie, indent, do_concat);
}
line_to_free = theline;
}
@ -2237,13 +2236,13 @@ void ex_function(exarg_T *eap)
// * ":python <<EOF" and "EOF"
// * ":let {var-name} =<< [trim] {marker}" and "{marker}"
if (heredoc_trimmed == NULL
|| (is_heredoc && (char_u *)skipwhite((char *)theline) == theline)
|| (is_heredoc && skipwhite(theline) == theline)
|| STRNCMP(theline, heredoc_trimmed,
STRLEN(heredoc_trimmed)) == 0) {
if (heredoc_trimmed == NULL) {
p = theline;
} else if (is_heredoc) {
p = (char_u *)skipwhite((char *)theline) == theline
p = skipwhite(theline) == theline
? theline : theline + STRLEN(heredoc_trimmed);
} else {
p = theline + STRLEN(heredoc_trimmed);
@ -2260,27 +2259,26 @@ void ex_function(exarg_T *eap)
for (p = theline; ascii_iswhite(*p) || *p == ':'; p++) {}
// Check for "endfunction".
if (checkforcmd((char **)&p, "endfunction", 4) && nesting-- == 0) {
if (checkforcmd(&p, "endfunction", 4) && nesting-- == 0) {
if (*p == '!') {
p++;
}
char_u *nextcmd = NULL;
char *nextcmd = NULL;
if (*p == '|') {
nextcmd = p + 1;
} else if (line_arg != NULL && *skipwhite((char *)line_arg) != NUL) {
} else if (line_arg != NULL && *skipwhite(line_arg) != NUL) {
nextcmd = line_arg;
} else if (*p != NUL && *p != '"' && p_verbose > 0) {
give_warning2(_("W22: Text found after :endfunction: %s"),
(char *)p, true);
give_warning2(_("W22: Text found after :endfunction: %s"), p, true);
}
if (nextcmd != NULL) {
// Another command follows. If the line came from "eap" we
// can simply point into it, otherwise we need to change
// "eap->cmdlinep".
eap->nextcmd = (char *)nextcmd;
eap->nextcmd = nextcmd;
if (line_to_free != NULL) {
xfree(*eap->cmdlinep);
*eap->cmdlinep = (char *)line_to_free;
*eap->cmdlinep = line_to_free;
line_to_free = NULL;
}
}
@ -2299,13 +2297,13 @@ void ex_function(exarg_T *eap)
}
// Check for defining a function inside this function.
if (checkforcmd((char **)&p, "function", 2)) {
if (checkforcmd(&p, "function", 2)) {
if (*p == '!') {
p = (char_u *)skipwhite((char *)p + 1);
p = skipwhite(p + 1);
}
p += eval_fname_script((const char *)p);
xfree(trans_function_name((char **)&p, true, 0, NULL, NULL));
if (*skipwhite((char *)p) == '(') {
xfree(trans_function_name(&p, true, 0, NULL, NULL));
if (*skipwhite(p) == '(') {
if (nesting == MAX_FUNC_NESTING - 1) {
emsg(_("E1058: function nesting too deep"));
} else {
@ -2316,7 +2314,7 @@ void ex_function(exarg_T *eap)
}
// Check for ":append", ":change", ":insert".
p = (char_u *)skip_range((char *)p, NULL);
p = skip_range(p, NULL);
if ((p[0] == 'a' && (!ASCII_ISALPHA(p[1]) || p[1] == 'p'))
|| (p[0] == 'c'
&& (!ASCII_ISALPHA(p[1])
@ -2328,11 +2326,11 @@ void ex_function(exarg_T *eap)
&& (!ASCII_ISALPHA(p[1]) || (p[1] == 'n'
&& (!ASCII_ISALPHA(p[2])
|| (p[2] == 's')))))) {
skip_until = vim_strsave((char_u *)".");
skip_until = xstrdup(".");
}
// heredoc: Check for ":python <<EOF", ":lua <<EOF", etc.
arg = (char_u *)skipwhite(skiptowhite((char *)p));
arg = skipwhite(skiptowhite(p));
if (arg[0] == '<' && arg[1] == '<'
&& ((p[0] == 'p' && p[1] == 'y'
&& (!ASCII_ISALNUM(p[2]) || p[2] == 't'
@ -2349,22 +2347,22 @@ void ex_function(exarg_T *eap)
|| (p[0] == 'm' && p[1] == 'z'
&& (!ASCII_ISALPHA(p[2]) || p[2] == 's')))) {
// ":python <<" continues until a dot, like ":append"
p = (char_u *)skipwhite((char *)arg + 2);
p = skipwhite(arg + 2);
if (*p == NUL) {
skip_until = vim_strsave((char_u *)".");
skip_until = xstrdup(".");
} else {
skip_until = vim_strsave(p);
skip_until = xstrdup(p);
}
}
// Check for ":let v =<< [trim] EOF"
// and ":let [a, b] =<< [trim] EOF"
arg = (char_u *)skipwhite(skiptowhite((char *)p));
arg = skipwhite(skiptowhite(p));
if (*arg == '[') {
arg = (char_u *)vim_strchr((char *)arg, ']');
arg = vim_strchr(arg, ']');
}
if (arg != NULL) {
arg = (char_u *)skipwhite(skiptowhite((char *)arg));
arg = skipwhite(skiptowhite(arg));
if (arg[0] == '='
&& arg[1] == '<'
&& arg[2] == '<'
@ -2372,14 +2370,13 @@ void ex_function(exarg_T *eap)
&& p[1] == 'e'
&& (!ASCII_ISALNUM(p[2])
|| (p[2] == 't' && !ASCII_ISALNUM(p[3]))))) {
p = (char_u *)skipwhite((char *)arg + 3);
p = skipwhite(arg + 3);
if (STRNCMP(p, "trim", 4) == 0) {
// Ignore leading white space.
p = (char_u *)skipwhite((char *)p + 4);
heredoc_trimmed =
vim_strnsave(theline, (size_t)((char_u *)skipwhite((char *)theline) - theline));
p = skipwhite(p + 4);
heredoc_trimmed = xstrnsave(theline, (size_t)(skipwhite(theline) - theline));
}
skip_until = vim_strnsave(p, (size_t)((char_u *)skiptowhite((char *)p) - p));
skip_until = xstrnsave(p, (size_t)(skiptowhite(p) - p));
do_concat = false;
is_heredoc = true;
}
@ -2392,8 +2389,8 @@ void ex_function(exarg_T *eap)
// Copy the line to newly allocated memory. get_one_sourceline()
// allocates 250 bytes per line, this saves 80% on average. The cost
// is an extra alloc/free.
p = vim_strsave(theline);
((char **)(newlines.ga_data))[newlines.ga_len++] = (char *)p;
p = xstrdup(theline);
((char **)(newlines.ga_data))[newlines.ga_len++] = p;
// Add NULL lines for continuation lines, so that the line count is
// equal to the index in the growarray.
@ -2420,23 +2417,23 @@ void ex_function(exarg_T *eap)
v = find_var((const char *)name, STRLEN(name), &ht, false);
if (v != NULL && v->di_tv.v_type == VAR_FUNC) {
emsg_funcname(N_("E707: Function name conflicts with variable: %s"),
name);
(char_u *)name);
goto erret;
}
fp = find_func(name);
fp = find_func((char_u *)name);
if (fp != NULL) {
// Function can be replaced with "function!" and when sourcing the
// same script again, but only once.
if (!eap->forceit
&& (fp->uf_script_ctx.sc_sid != current_sctx.sc_sid
|| fp->uf_script_ctx.sc_seq == current_sctx.sc_seq)) {
emsg_funcname(e_funcexts, name);
emsg_funcname(e_funcexts, (char_u *)name);
goto erret;
}
if (fp->uf_calls > 0) {
emsg_funcname(N_("E127: Cannot redefine function %s: It is in use"),
name);
(char_u *)name);
goto erret;
}
if (fp->uf_refcount > 1) {
@ -2480,12 +2477,12 @@ void ex_function(exarg_T *eap)
// Give the function a sequential number. Can only be used with a
// Funcref!
xfree(name);
sprintf(numbuf, "%d", ++func_nr);
name = vim_strsave((char_u *)numbuf);
sprintf(numbuf, "%d", ++func_nr); // NOLINT(runtime/printf)
name = xstrdup(numbuf);
}
if (fp == NULL) {
if (fudi.fd_dict == NULL && vim_strchr((char *)name, AUTOLOAD_CHAR) != NULL) {
if (fudi.fd_dict == NULL && vim_strchr(name, AUTOLOAD_CHAR) != NULL) {
int slen, plen;
char_u *scriptname;
@ -2493,7 +2490,7 @@ void ex_function(exarg_T *eap)
int j = FAIL;
if (SOURCING_NAME != NULL) {
scriptname = (char_u *)autoload_name((const char *)name, STRLEN(name));
p = (char_u *)vim_strchr((char *)scriptname, '/');
p = vim_strchr((char *)scriptname, '/');
plen = (int)STRLEN(p);
slen = (int)STRLEN(SOURCING_NAME);
if (slen > plen && FNAMECMP(p, SOURCING_NAME + slen - plen) == 0) {
@ -2524,16 +2521,16 @@ void ex_function(exarg_T *eap)
tv_clear(&fudi.fd_di->di_tv);
}
fudi.fd_di->di_tv.v_type = VAR_FUNC;
fudi.fd_di->di_tv.vval.v_string = (char *)vim_strsave(name);
fudi.fd_di->di_tv.vval.v_string = xstrdup(name);
// behave like "dict" was used
flags |= FC_DICT;
}
// insert the new function in the function list
set_ufunc_name(fp, name);
set_ufunc_name(fp, (char_u *)name);
if (overwrite) {
hi = hash_find(&func_hashtab, (char *)name);
hi = hash_find(&func_hashtab, name);
hi->hi_key = UF2HIKEY(fp);
} else if (hash_add(&func_hashtab, UF2HIKEY(fp)) == FAIL) {
xfree(fp);
@ -3213,7 +3210,7 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
? (char_u *)rettv->vval.v_string
: rettv->vval.v_partial->pt_name;
// Translate "s:func" to the stored function name.
fname = fname_trans_sid(fname, fname_buf, &tofree, &error);
fname = (char_u *)fname_trans_sid((char *)fname, (char *)fname_buf, (char **)&tofree, &error);
fp = find_func(fname);
xfree(tofree);
}
@ -3559,7 +3556,7 @@ bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
}
if (fp_in == NULL) {
fname = fname_trans_sid(name, fname_buf, &tofree, &error);
fname = (char_u *)fname_trans_sid((char *)name, (char *)fname_buf, (char **)&tofree, &error);
fp = find_func(fname);
}
if (fp != NULL) {

8
src/nvim/ex_cmds.c
View File

@ -330,7 +330,7 @@ static int linelen(int *has_tab)
// Get the line. If it's empty bail out early (could be the empty string
// for an unloaded buffer).
line = (char *)get_cursor_line_ptr();
line = get_cursor_line_ptr();
if (*line == NUL) {
return 0;
}
@ -601,7 +601,7 @@ void ex_sort(exarg_T *eap)
nrs[lnum - eap->line1].st_u.num.value = 0;
} else {
nrs[lnum - eap->line1].st_u.num.is_number = true;
vim_str2nr((char_u *)s, NULL, NULL, sort_what,
vim_str2nr(s, NULL, NULL, sort_what,
&nrs[lnum - eap->line1].st_u.num.value, NULL, 0, false);
}
} else {
@ -2808,7 +2808,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
// keep it. Also when it moves within a line. But not when it moves
// to the first non-blank.
if (!equalpos(curwin->w_cursor, orig_pos)) {
const char *text = (char *)get_cursor_line_ptr();
const char *text = get_cursor_line_ptr();
if (curwin->w_cursor.lnum != orig_pos.lnum
|| curwin->w_cursor.col != (int)(skipwhite(text) - text)) {
@ -3354,7 +3354,7 @@ static bool sub_joining_lines(exarg_T *eap, char *pat, char *sub, char *cmd, boo
save_re_pat(RE_SUBST, (char_u *)pat, p_magic);
}
// put pattern in history
add_to_history(HIST_SEARCH, (char_u *)pat, true, NUL);
add_to_history(HIST_SEARCH, pat, true, NUL);
}
return true;

4
src/nvim/ex_docmd.c
View File

@ -3694,7 +3694,7 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
// Decide to expand wildcards *before* replacing '%', '#', etc. If
// the file name contains a wildcard it should not cause expanding.
// (it will be expanded anyway if there is a wildcard before replacing).
int has_wildcards = path_has_wildcard((char_u *)p);
int has_wildcards = path_has_wildcard(p);
while (*p != NUL) {
// Skip over `=expr`, wildcards in it are not expanded.
if (p[0] == '`' && p[1] == '=') {
@ -3799,7 +3799,7 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
if (vim_strchr(eap->arg, '$') != NULL
|| vim_strchr(eap->arg, '~') != NULL) {
expand_env_esc((char_u *)eap->arg, (char_u *)NameBuff, MAXPATHL, true, true, NULL);
has_wildcards = path_has_wildcard((char_u *)NameBuff);
has_wildcards = path_has_wildcard(NameBuff);
p = (char *)NameBuff;
} else {
p = NULL;

134
src/nvim/ex_getln.c
View File

@ -255,7 +255,7 @@ static bool do_incsearch_highlighting(int firstc, int *search_delim, incsearch_s
exarg_T ea = {
.line1 = 1,
.line2 = 1,
.cmd = (char *)ccline.cmdbuff,
.cmd = ccline.cmdbuff,
.addr_type = ADDR_LINES,
};
@ -336,7 +336,7 @@ static bool do_incsearch_highlighting(int firstc, int *search_delim, incsearch_s
}
// found a non-empty pattern or //
*skiplen = (int)((char_u *)p - ccline.cmdbuff);
*skiplen = (int)(p - ccline.cmdbuff);
*patlen = (int)(end - p);
// parse the address range
@ -409,7 +409,7 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
int found; // do_search() result
// Use the previous pattern for ":s//".
next_char = ccline.cmdbuff[skiplen + patlen];
next_char = (char_u)ccline.cmdbuff[skiplen + patlen];
use_last_pat = patlen == 0 && skiplen > 0
&& ccline.cmdbuff[skiplen - 1] == next_char;
@ -436,9 +436,9 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
.sa_tm = &tm,
};
found = do_search(NULL, firstc == ':' ? '/' : firstc, search_delim,
ccline.cmdbuff + skiplen, count,
(char_u *)ccline.cmdbuff + skiplen, count,
search_flags, &sia);
ccline.cmdbuff[skiplen + patlen] = next_char;
ccline.cmdbuff[skiplen + patlen] = (char)next_char;
emsg_off--;
if (curwin->w_cursor.lnum < search_first_line
|| curwin->w_cursor.lnum > search_last_line) {
@ -487,13 +487,13 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
// Disable 'hlsearch' highlighting if the pattern matches
// everything. Avoids a flash when typing "foo\|".
if (!use_last_pat) {
next_char = ccline.cmdbuff[skiplen + patlen];
next_char = (char_u)ccline.cmdbuff[skiplen + patlen];
ccline.cmdbuff[skiplen + patlen] = NUL;
if (empty_pattern((char *)ccline.cmdbuff) && !no_hlsearch) {
if (empty_pattern(ccline.cmdbuff) && !no_hlsearch) {
redraw_all_later(UPD_SOME_VALID);
set_no_hlsearch(true);
}
ccline.cmdbuff[skiplen + patlen] = next_char;
ccline.cmdbuff[skiplen + patlen] = (char)next_char;
}
validate_cursor();
@ -548,7 +548,7 @@ static int may_add_char_to_search(int firstc, int *c, incsearch_state_T *s)
// command line has no uppercase characters, convert
// the character to lowercase
if (p_ic && p_scs
&& !pat_has_uppercase(ccline.cmdbuff + skiplen)) {
&& !pat_has_uppercase((char_u *)ccline.cmdbuff + skiplen)) {
*c = mb_tolower(*c);
}
if (*c == search_delim
@ -724,7 +724,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
if (ccline.input_fn) {
s->xpc.xp_context = ccline.xp_context;
s->xpc.xp_pattern = (char *)ccline.cmdbuff;
s->xpc.xp_pattern = ccline.cmdbuff;
s->xpc.xp_arg = (char *)ccline.xp_arg;
}
@ -854,7 +854,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
s->histype == HIST_SEARCH ? s->firstc : NUL);
if (s->firstc == ':') {
xfree(new_last_cmdline);
new_last_cmdline = (char *)vim_strsave(ccline.cmdbuff);
new_last_cmdline = xstrdup(ccline.cmdbuff);
}
}
@ -897,7 +897,7 @@ theend:
xfree(ccline.last_colors.cmdbuff);
kv_destroy(ccline.last_colors.colors);
char_u *p = ccline.cmdbuff;
char_u *p = (char_u *)ccline.cmdbuff;
if (ui_has(kUICmdline)) {
ui_call_cmdline_hide(ccline.level);
@ -1339,7 +1339,7 @@ static int may_do_command_line_next_incsearch(int firstc, long count, incsearch_
skiplen = 0;
patlen = (int)STRLEN(pat);
} else {
pat = ccline.cmdbuff + skiplen;
pat = (char_u *)ccline.cmdbuff + skiplen;
}
if (next_match) {
@ -1483,24 +1483,24 @@ static int command_line_handle_key(CommandLineState *s)
}
if (s->c == K_DEL) {
ccline.cmdpos += mb_off_next(ccline.cmdbuff,
ccline.cmdbuff + ccline.cmdpos);
ccline.cmdpos += mb_off_next((char_u *)ccline.cmdbuff,
(char_u *)ccline.cmdbuff + ccline.cmdpos);
}
if (ccline.cmdpos > 0) {
char_u *p;
int j = ccline.cmdpos;
p = mb_prevptr(ccline.cmdbuff, ccline.cmdbuff + j);
p = mb_prevptr((char_u *)ccline.cmdbuff, (char_u *)ccline.cmdbuff + j);
if (s->c == Ctrl_W) {
while (p > ccline.cmdbuff && ascii_isspace(*p)) {
p = mb_prevptr(ccline.cmdbuff, p);
while (p > (char_u *)ccline.cmdbuff && ascii_isspace(*p)) {
p = mb_prevptr((char_u *)ccline.cmdbuff, p);
}
int i = mb_get_class(p);
while (p > ccline.cmdbuff && mb_get_class(p) == i) {
p = mb_prevptr(ccline.cmdbuff, p);
while (p > (char_u *)ccline.cmdbuff && mb_get_class(p) == i) {
p = mb_prevptr((char_u *)ccline.cmdbuff, p);
}
if (mb_get_class(p) != i) {
@ -1508,7 +1508,7 @@ static int command_line_handle_key(CommandLineState *s)
}
}
ccline.cmdpos = (int)(p - ccline.cmdbuff);
ccline.cmdpos = (int)(p - (char_u *)ccline.cmdbuff);
ccline.cmdlen -= j - ccline.cmdpos;
int i = ccline.cmdpos;
@ -1688,7 +1688,7 @@ static int command_line_handle_key(CommandLineState *s)
}
ccline.cmdspos += cells;
ccline.cmdpos += utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos);
ccline.cmdpos += utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos);
} while ((s->c == K_S_RIGHT || s->c == K_C_RIGHT
|| (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)))
&& ccline.cmdbuff[ccline.cmdpos] != ' ');
@ -1704,8 +1704,8 @@ static int command_line_handle_key(CommandLineState *s)
do {
ccline.cmdpos--;
// Move to first byte of possibly multibyte char.
ccline.cmdpos -= utf_head_off((char *)ccline.cmdbuff,
(char *)ccline.cmdbuff + ccline.cmdpos);
ccline.cmdpos -= utf_head_off(ccline.cmdbuff,
ccline.cmdbuff + ccline.cmdpos);
ccline.cmdspos -= cmdline_charsize(ccline.cmdpos);
} while (ccline.cmdpos > 0
&& (s->c == K_S_LEFT || s->c == K_C_LEFT
@ -1761,7 +1761,7 @@ static int command_line_handle_key(CommandLineState *s)
// Count ">" for double-wide char that doesn't fit.
correct_screencol(ccline.cmdpos, cells, &ccline.cmdspos);
ccline.cmdpos += utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos) - 1;
ccline.cmdpos += utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos) - 1;
ccline.cmdspos += cells;
}
return command_line_not_changed(s);
@ -1855,7 +1855,7 @@ static int command_line_handle_key(CommandLineState *s)
// save current command string so it can be restored later
if (s->lookfor == NULL) {
s->lookfor = vim_strsave(ccline.cmdbuff);
s->lookfor = vim_strsave((char_u *)ccline.cmdbuff);
s->lookfor[ccline.cmdpos] = NUL;
}
@ -1874,7 +1874,7 @@ static int command_line_handle_key(CommandLineState *s)
if (s->hiscnt == get_hislen()) {
p = s->lookfor; // back to the old one
} else {
p = get_histentry(s->histype)[s->hiscnt].hisstr;
p = (char_u *)get_histentry(s->histype)[s->hiscnt].hisstr;
}
if (s->histype == HIST_SEARCH
@ -1892,7 +1892,7 @@ static int command_line_handle_key(CommandLineState *s)
if (p[j] == old_firstc
&& (j == 0 || p[j - 1] != '\\')) {
if (i > 0) {
ccline.cmdbuff[len] = (char_u)s->firstc;
ccline.cmdbuff[len] = (char)s->firstc;
}
} else {
// Escape new sep, unless it is already
@ -1906,7 +1906,7 @@ static int command_line_handle_key(CommandLineState *s)
}
if (i > 0) {
ccline.cmdbuff[len] = p[j];
ccline.cmdbuff[len] = (char)p[j];
}
}
len++;
@ -2281,7 +2281,7 @@ static bool cmdpreview_may_show(CommandLineState *s)
CmdParseInfo cmdinfo;
// Copy the command line so we can modify it.
int cmdpreview_type = 0;
char *cmdline = xstrdup((char *)ccline.cmdbuff);
char *cmdline = xstrdup(ccline.cmdbuff);
char *errormsg = NULL;
emsg_off++; // Block errors when parsing the command line, and don't update v:errmsg
if (!parse_cmdline(cmdline, &ea, &cmdinfo, &errormsg)) {
@ -2659,7 +2659,7 @@ static int cmdline_charsize(int idx)
if (cmdline_star > 0) { // showing '*', always 1 position
return 1;
}
return ptr2cells((char *)ccline.cmdbuff + idx);
return ptr2cells(ccline.cmdbuff + idx);
}
/// Compute the offset of the cursor on the command line for the prompt and
@ -2685,7 +2685,7 @@ int cmd_screencol(int bytepos)
}
for (int i = 0; i < ccline.cmdlen && i < bytepos;
i += utfc_ptr2len((char *)ccline.cmdbuff + i)) {
i += utfc_ptr2len(ccline.cmdbuff + i)) {
int c = cmdline_charsize(i);
// Count ">" for double-wide multi-byte char that doesn't fit.
correct_screencol(i, c, &col);
@ -2704,8 +2704,8 @@ int cmd_screencol(int bytepos)
/// character that doesn't fit, so that a ">" must be displayed.
static void correct_screencol(int idx, int cells, int *col)
{
if (utfc_ptr2len((char *)ccline.cmdbuff + idx) > 1
&& utf_ptr2cells((char *)ccline.cmdbuff + idx) > 1
if (utfc_ptr2len(ccline.cmdbuff + idx) > 1
&& utf_ptr2cells(ccline.cmdbuff + idx) > 1
&& (*col) % Columns + cells > Columns) {
(*col)++;
}
@ -2764,7 +2764,7 @@ void realloc_cmdbuff(int len)
return; // no need to resize
}
char_u *p = ccline.cmdbuff;
char_u *p = (char_u *)ccline.cmdbuff;
alloc_cmdbuff(len); // will get some more
// There isn't always a NUL after the command, but it may need to be
// there, thus copy up to the NUL and add a NUL.
@ -2781,7 +2781,7 @@ void realloc_cmdbuff(int len)
// If xp_pattern points inside the old cmdbuff it needs to be adjusted
// to point into the newly allocated memory.
if (i >= 0 && i <= ccline.cmdlen) {
ccline.xpc->xp_pattern = (char *)ccline.cmdbuff + i;
ccline.xpc->xp_pattern = ccline.cmdbuff + i;
}
}
}
@ -2904,7 +2904,7 @@ static bool color_cmdline(CmdlineInfo *colored_ccline)
bool arg_allocated = false;
typval_T arg = {
.v_type = VAR_STRING,
.vval.v_string = (char *)colored_ccline->cmdbuff,
.vval.v_string = colored_ccline->cmdbuff,
};
typval_T tv = { .v_type = VAR_UNKNOWN };
@ -3107,16 +3107,16 @@ static void draw_cmdline(int start, int len)
if (cmdline_star > 0) {
for (int i = 0; i < len; i++) {
msg_putchar('*');
i += utfc_ptr2len((char *)ccline.cmdbuff + start + i) - 1;
i += utfc_ptr2len(ccline.cmdbuff + start + i) - 1;
}
} else if (p_arshape && !p_tbidi && len > 0) {
bool do_arabicshape = false;
int mb_l;
for (int i = start; i < start + len; i += mb_l) {
char_u *p = ccline.cmdbuff + i;
char_u *p = (char_u *)ccline.cmdbuff + i;
int u8cc[MAX_MCO];
int u8c = utfc_ptr2char_len(p, u8cc, start + len - i);
mb_l = utfc_ptr2len_len(p, start + len - i);
mb_l = utfc_ptr2len_len((char *)p, start + len - i);
if (ARABIC_CHAR(u8c)) {
do_arabicshape = true;
break;
@ -3140,7 +3140,7 @@ static void draw_cmdline(int start, int len)
}
int newlen = 0;
if (utf_iscomposing(utf_ptr2char((char *)ccline.cmdbuff + start))) {
if (utf_iscomposing(utf_ptr2char(ccline.cmdbuff + start))) {
// Prepend a space to draw the leading composing char on.
arshape_buf[0] = ' ';
newlen = 1;
@ -3149,10 +3149,10 @@ static void draw_cmdline(int start, int len)
int prev_c = 0;
int prev_c1 = 0;
for (int i = start; i < start + len; i += mb_l) {
char_u *p = ccline.cmdbuff + i;
char_u *p = (char_u *)ccline.cmdbuff + i;
int u8cc[MAX_MCO];
int u8c = utfc_ptr2char_len(p, u8cc, start + len - i);
mb_l = utfc_ptr2len_len(p, start + len - i);
mb_l = utfc_ptr2len_len((char *)p, start + len - i);
if (ARABIC_CHAR(u8c)) {
int pc;
int pc1 = 0;
@ -3208,12 +3208,12 @@ draw_cmdline_no_arabicshape:
continue;
}
const int chunk_start = MAX(chunk.start, start);
msg_outtrans_len_attr((char *)ccline.cmdbuff + chunk_start,
msg_outtrans_len_attr(ccline.cmdbuff + chunk_start,
chunk.end - chunk_start,
chunk.attr);
}
} else {
msg_outtrans_len((char *)ccline.cmdbuff + start, len);
msg_outtrans_len(ccline.cmdbuff + start, len);
}
}
}
@ -3225,7 +3225,7 @@ static void ui_ext_cmdline_show(CmdlineInfo *line)
if (cmdline_star) {
content = arena_array(&arena, 1);
size_t len = 0;
for (char_u *p = ccline.cmdbuff; *p; MB_PTR_ADV(p)) {
for (char_u *p = (char_u *)ccline.cmdbuff; *p; MB_PTR_ADV(p)) {
len++;
}
char *buf = arena_alloc(&arena, len, false);
@ -3380,7 +3380,7 @@ void unputcmdline(void)
if (ccline.cmdlen == ccline.cmdpos && !ui_has(kUICmdline)) {
msg_putchar(' ');
} else {
draw_cmdline(ccline.cmdpos, utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos));
draw_cmdline(ccline.cmdpos, utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos));
}
msg_no_more = false;
cursorcmd();
@ -3422,7 +3422,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
// Count nr of bytes in cmdline that are overwritten by these
// characters.
for (i = ccline.cmdpos; i < ccline.cmdlen && m > 0;
i += utfc_ptr2len((char *)ccline.cmdbuff + i)) {
i += utfc_ptr2len(ccline.cmdbuff + i)) {
m--;
}
if (i < ccline.cmdlen) {
@ -3440,17 +3440,17 @@ void put_on_cmdline(char_u *str, int len, int redraw)
// When the inserted text starts with a composing character,
// backup to the character before it. There could be two of them.
i = 0;
c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
while (ccline.cmdpos > 0 && utf_iscomposing(c)) {
i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
ccline.cmdpos -= i;
len += i;
c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
}
if (i == 0 && ccline.cmdpos > 0 && arabic_maycombine(c)) {
// Check the previous character for Arabic combining pair.
i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
if (arabic_combine(utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos - i), c)) {
i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
if (arabic_combine(utf_ptr2char(ccline.cmdbuff + ccline.cmdpos - i), c)) {
ccline.cmdpos -= i;
len += i;
} else {
@ -3459,7 +3459,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
}
if (i != 0) {
// Also backup the cursor position.
i = ptr2cells((char *)ccline.cmdbuff + ccline.cmdpos);
i = ptr2cells(ccline.cmdbuff + ccline.cmdpos);
ccline.cmdspos -= i;
msg_col -= i;
if (msg_col < 0) {
@ -3498,7 +3498,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
if (ccline.cmdspos + c < m) {
ccline.cmdspos += c;
}
c = utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos) - 1;
c = utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos) - 1;
if (c > len - i - 1) {
c = len - i - 1;
}
@ -3580,14 +3580,14 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
int len;
// Locate start of last word in the cmd buffer.
for (w = ccline.cmdbuff + ccline.cmdpos; w > ccline.cmdbuff;) {
len = utf_head_off((char *)ccline.cmdbuff, (char *)w - 1) + 1;
for (w = (char_u *)ccline.cmdbuff + ccline.cmdpos; w > (char_u *)ccline.cmdbuff;) {
len = utf_head_off(ccline.cmdbuff, (char *)w - 1) + 1;
if (!vim_iswordc(utf_ptr2char((char *)w - len))) {
break;
}
w -= len;
}
len = (int)((ccline.cmdbuff + ccline.cmdpos) - w);
len = (int)(((char_u *)ccline.cmdbuff + ccline.cmdpos) - w);
if (p_ic ? STRNICMP(w, arg, len) == 0 : STRNCMP(w, arg, len) == 0) {
p += len;
}
@ -3823,7 +3823,7 @@ static int ccheck_abbr(int c)
spos = 0;
}
return check_abbr(c, ccline.cmdbuff, ccline.cmdpos, spos);
return check_abbr(c, (char_u *)ccline.cmdbuff, ccline.cmdpos, spos);
}
/// Escape special characters in "fname", depending on "what":
@ -3964,7 +3964,7 @@ static char *get_cmdline_str(void)
if (p == NULL) {
return NULL;
}
return (char *)vim_strnsave(p->cmdbuff, (size_t)p->cmdlen);
return xstrnsave(p->cmdbuff, (size_t)p->cmdlen);
}
/// Get the current command-line completion type.
@ -4126,7 +4126,7 @@ int get_list_range(char **str, int *num1, int *num2)
*str = skipwhite((*str));
if (**str == '-' || ascii_isdigit(**str)) { // parse "from" part of range
vim_str2nr((char_u *)(*str), NULL, &len, 0, &num, NULL, 0, false);
vim_str2nr(*str, NULL, &len, 0, &num, NULL, 0, false);
*str += len;
*num1 = (int)num;
first = true;
@ -4134,7 +4134,7 @@ int get_list_range(char **str, int *num1, int *num2)
*str = skipwhite((*str));
if (**str == ',') { // parse "to" part of range
*str = skipwhite((*str) + 1);
vim_str2nr((char_u *)(*str), NULL, &len, 0, &num, NULL, 0, false);
vim_str2nr(*str, NULL, &len, 0, &num, NULL, 0, false);
if (len > 0) {
*num2 = (int)num;
*str = skipwhite((*str) + len);
@ -4270,7 +4270,7 @@ static int open_cmdwin(void)
i = 0;
}
if (get_histentry(histtype)[i].hisstr != NULL) {
ml_append(lnum++, (char *)get_histentry(histtype)[i].hisstr, (colnr_T)0, false);
ml_append(lnum++, get_histentry(histtype)[i].hisstr, (colnr_T)0, false);
}
} while (i != *get_hisidx(histtype));
}
@ -4278,7 +4278,7 @@ static int open_cmdwin(void)
// Replace the empty last line with the current command-line and put the
// cursor there.
ml_replace(curbuf->b_ml.ml_line_count, (char *)ccline.cmdbuff, true);
ml_replace(curbuf->b_ml.ml_line_count, ccline.cmdbuff, true);
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
curwin->w_cursor.col = ccline.cmdpos;
changed_line_abv_curs();
@ -4348,7 +4348,7 @@ static int open_cmdwin(void)
if (histtype == HIST_CMD) {
// Execute the command directly.
ccline.cmdbuff = (char_u *)xstrdup(p);
ccline.cmdbuff = xstrdup(p);
cmdwin_result = CAR;
} else {
// First need to cancel what we were doing.
@ -4362,10 +4362,10 @@ static int open_cmdwin(void)
// and don't modify the cmd window.
ccline.cmdbuff = NULL;
} else {
ccline.cmdbuff = vim_strsave(get_cursor_line_ptr());
ccline.cmdbuff = xstrdup(get_cursor_line_ptr());
}
if (ccline.cmdbuff == NULL) {
ccline.cmdbuff = vim_strsave((char_u *)"");
ccline.cmdbuff = xstrdup("");
ccline.cmdlen = 0;
ccline.cmdbufflen = 1;
ccline.cmdpos = 0;

2
src/nvim/ex_getln.h
View File

@ -41,7 +41,7 @@ typedef enum {
/// structure.
typedef struct cmdline_info CmdlineInfo;
struct cmdline_info {
char_u *cmdbuff; ///< pointer to command line buffer
char *cmdbuff; ///< pointer to command line buffer
int cmdbufflen; ///< length of cmdbuff
int cmdlen; ///< number of chars in command line
int cmdpos; ///< current cursor position

104
src/nvim/file_search.c
View File

@ -174,12 +174,12 @@ typedef struct ff_search_ctx_T {
ff_visited_list_hdr_T *ffsc_dir_visited_list;
ff_visited_list_hdr_T *ffsc_visited_lists_list;
ff_visited_list_hdr_T *ffsc_dir_visited_lists_list;
char_u *ffsc_file_to_search;
char_u *ffsc_start_dir;
char_u *ffsc_fix_path;
char_u *ffsc_wc_path;
char *ffsc_file_to_search;
char *ffsc_start_dir;
char *ffsc_fix_path;
char *ffsc_wc_path;
int ffsc_level;
char_u **ffsc_stopdirs_v;
char **ffsc_stopdirs_v;
int ffsc_find_what;
int ffsc_tagfile;
} ff_search_ctx_T;
@ -245,11 +245,10 @@ static char_u e_pathtoolong[] = N_("E854: path too long for completion");
///
/// @param tagfile expanding names of tags files
/// @param rel_fname file name to use for "."
void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int level,
int free_visited, int find_what, void *search_ctx_arg, int tagfile,
char_u *rel_fname)
void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, int free_visited,
int find_what, void *search_ctx_arg, int tagfile, char *rel_fname)
{
char_u *wc_part;
char *wc_part;
ff_stack_T *sptr;
ff_search_ctx_T *search_ctx;
@ -274,12 +273,12 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
/* Reuse old visited lists. Get the visited list for the given
* filename. If no list for the current filename exists, creates a new
* one. */
search_ctx->ffsc_visited_list = ff_get_visited_list(filename,
search_ctx->ffsc_visited_list = ff_get_visited_list((char_u *)filename,
&search_ctx->ffsc_visited_lists_list);
if (search_ctx->ffsc_visited_list == NULL) {
goto error_return;
}
search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename,
search_ctx->ffsc_dir_visited_list = ff_get_visited_list((char_u *)filename,
&search_ctx->ffsc_dir_visited_lists_list);
if (search_ctx->ffsc_dir_visited_list == NULL) {
goto error_return;
@ -296,19 +295,19 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
&& (vim_ispathsep(path[1]) || path[1] == NUL)
&& (!tagfile || vim_strchr(p_cpo, CPO_DOTTAG) == NULL)
&& rel_fname != NULL) {
size_t len = (size_t)((char_u *)path_tail((char *)rel_fname) - rel_fname);
size_t len = (size_t)(path_tail(rel_fname) - rel_fname);
if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL) {
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);
search_ctx->ffsc_start_dir = (char_u *)FullName_save((char *)ff_expand_buffer, false);
search_ctx->ffsc_start_dir = FullName_save((char *)ff_expand_buffer, false);
} else {
search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len);
search_ctx->ffsc_start_dir = xstrnsave(rel_fname, len);
}
if (*++path != NUL) {
path++;
}
} else if (*path == NUL || !vim_isAbsName(path)) {
} else if (*path == NUL || !vim_isAbsName((char_u *)path)) {
#ifdef BACKSLASH_IN_FILENAME
// "c:dir" needs "c:" to be expanded, otherwise use current dir
if (*path != NUL && path[1] == ':') {
@ -329,7 +328,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
goto error_return;
}
search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer);
search_ctx->ffsc_start_dir = (char *)vim_strsave(ff_expand_buffer);
#ifdef BACKSLASH_IN_FILENAME
/* A path that starts with "/dir" is relative to the drive, not to the
@ -352,7 +351,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
* ff_path_in_stoplist() for details.
*/
if (stopdirs != NULL) {
char_u *walker = stopdirs;
char *walker = stopdirs;
while (*walker == ';') {
walker++;
@ -362,25 +361,23 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
search_ctx->ffsc_stopdirs_v = xmalloc(sizeof(char_u *));
do {
char_u *helper;
char *helper;
void *ptr;
helper = walker;
ptr = xrealloc(search_ctx->ffsc_stopdirs_v,
(dircount + 1) * sizeof(char_u *));
search_ctx->ffsc_stopdirs_v = ptr;
walker = (char_u *)vim_strchr((char *)walker, ';');
walker = vim_strchr(walker, ';');
if (walker) {
assert(walker - helper >= 0);
search_ctx->ffsc_stopdirs_v[dircount - 1] =
vim_strnsave(helper, (size_t)(walker - helper));
search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrnsave(helper, (size_t)(walker - helper));
walker++;
} else {
/* this might be "", which means ascent till top
* of directory tree.
*/
search_ctx->ffsc_stopdirs_v[dircount - 1] =
vim_strsave(helper);
search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrdup(helper);
}
dircount++;
@ -394,7 +391,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
* -fix path
* -wildcard_stuff (might be NULL)
*/
wc_part = (char_u *)vim_strchr((char *)path, '*');
wc_part = vim_strchr(path, '*');
if (wc_part != NULL) {
int64_t llevel;
int len;
@ -402,7 +399,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
// save the fix part of the path
assert(wc_part - path >= 0);
search_ctx->ffsc_fix_path = vim_strnsave(path, (size_t)(wc_part - path));
search_ctx->ffsc_fix_path = xstrnsave(path, (size_t)(wc_part - path));
/*
* copy wc_path and add restricts to the '**' wildcard.
@ -420,19 +417,19 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
break;
}
if (STRNCMP(wc_part, "**", 2) == 0) {
ff_expand_buffer[len++] = *wc_part++;
ff_expand_buffer[len++] = *wc_part++;
ff_expand_buffer[len++] = (char_u)(*wc_part++);
ff_expand_buffer[len++] = (char_u)(*wc_part++);
llevel = strtol((char *)wc_part, &errpt, 10);
if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255) {
llevel = strtol(wc_part, &errpt, 10);
if (errpt != wc_part && llevel > 0 && llevel < 255) {
ff_expand_buffer[len++] = (char_u)llevel;
} else if ((char_u *)errpt != wc_part && llevel == 0) {
} else if (errpt != wc_part && llevel == 0) {
// restrict is 0 -> remove already added '**'
len -= 2;
} else {
ff_expand_buffer[len++] = FF_MAX_STAR_STAR_EXPAND;
}
wc_part = (char_u *)errpt;
wc_part = errpt;
if (*wc_part != NUL && !vim_ispathsep(*wc_part)) {
semsg(_(
"E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."),
@ -440,20 +437,20 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
goto error_return;
}
} else {
ff_expand_buffer[len++] = *wc_part++;
ff_expand_buffer[len++] = (char_u)(*wc_part++);
}
}
ff_expand_buffer[len] = NUL;
search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer);
search_ctx->ffsc_wc_path = (char *)vim_strsave(ff_expand_buffer);
} else {
search_ctx->ffsc_fix_path = vim_strsave(path);
search_ctx->ffsc_fix_path = xstrdup(path);
}
if (search_ctx->ffsc_start_dir == NULL) {
/* store the fix part as startdir.
* This is needed if the parameter path is fully qualified.
*/
search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path);
search_ctx->ffsc_start_dir = xstrdup(search_ctx->ffsc_fix_path);
search_ctx->ffsc_fix_path[0] = NUL;
}
@ -475,9 +472,9 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path);
add_pathsep((char *)ff_expand_buffer);
} else {
char_u *p = (char_u *)path_tail((char *)search_ctx->ffsc_fix_path);
char_u *wc_path = NULL;
char_u *temp = NULL;
char *p = path_tail(search_ctx->ffsc_fix_path);
char *wc_path = NULL;
char *temp = NULL;
int len = 0;
if (p > search_ctx->ffsc_fix_path) {
@ -495,7 +492,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
}
if (search_ctx->ffsc_wc_path != NULL) {
wc_path = vim_strsave(search_ctx->ffsc_wc_path);
wc_path = xstrdup(search_ctx->ffsc_wc_path);
temp = xmalloc(STRLEN(search_ctx->ffsc_wc_path)
+ STRLEN(search_ctx->ffsc_fix_path + len)
+ 1);
@ -509,10 +506,10 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
xfree(buf);
}
sptr = ff_create_stack_element(ff_expand_buffer, search_ctx->ffsc_wc_path, level, 0);
sptr = ff_create_stack_element(ff_expand_buffer, (char_u *)search_ctx->ffsc_wc_path, level, 0);
ff_push(search_ctx, sptr);
search_ctx->ffsc_file_to_search = vim_strsave(filename);
search_ctx->ffsc_file_to_search = xstrdup(filename);
return search_ctx;
error_return:
@ -598,8 +595,7 @@ char_u *vim_findfile(void *search_ctx_arg)
// store the end of the start dir -- needed for upward search
if (search_ctx->ffsc_start_dir != NULL) {
path_end = &search_ctx->ffsc_start_dir[
STRLEN(search_ctx->ffsc_start_dir)];
path_end = (char_u *)&search_ctx->ffsc_start_dir[STRLEN(search_ctx->ffsc_start_dir)];
}
// upward search loop
@ -930,19 +926,17 @@ char_u *vim_findfile(void *search_ctx_arg)
ff_stack_T *sptr;
// is the last starting directory in the stop list?
if (ff_path_in_stoplist(search_ctx->ffsc_start_dir,
(int)(path_end - search_ctx->ffsc_start_dir),
search_ctx->ffsc_stopdirs_v) == true) {
if (ff_path_in_stoplist((char_u *)search_ctx->ffsc_start_dir,
(int)(path_end - (char_u *)search_ctx->ffsc_start_dir),
(char_u **)search_ctx->ffsc_stopdirs_v) == true) {
break;
}
// cut of last dir
while (path_end > search_ctx->ffsc_start_dir
&& vim_ispathsep(*path_end)) {
while (path_end > (char_u *)search_ctx->ffsc_start_dir && vim_ispathsep(*path_end)) {
path_end--;
}
while (path_end > search_ctx->ffsc_start_dir
&& !vim_ispathsep(path_end[-1])) {
while (path_end > (char_u *)search_ctx->ffsc_start_dir && !vim_ispathsep(path_end[-1])) {
path_end--;
}
*path_end = 0;
@ -964,7 +958,7 @@ char_u *vim_findfile(void *search_ctx_arg)
// create a new stack entry
sptr = ff_create_stack_element(file_path,
search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
(char_u *)search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
ff_push(search_ctx, sptr);
} else {
break;
@ -1528,9 +1522,9 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
// get the stopdir string
r_ptr = vim_findfile_stopdir((char_u *)buf);
fdip_search_ctx = vim_findfile_init((char_u *)buf, ff_file_to_find,
r_ptr, 100, false, find_what,
fdip_search_ctx, false, rel_fname);
fdip_search_ctx = vim_findfile_init(buf, (char *)ff_file_to_find,
(char *)r_ptr, 100, false, find_what,
fdip_search_ctx, false, (char *)rel_fname);
if (fdip_search_ctx != NULL) {
did_findfile_init = true;
}

22
src/nvim/fileio.c
View File

@ -719,7 +719,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
fenc_alloced = false;
} else {
fenc_next = p_fencs; // try items in 'fileencodings'
fenc = (char *)next_fenc(&fenc_next, &fenc_alloced);
fenc = next_fenc(&fenc_next, &fenc_alloced);
}
/*
@ -813,7 +813,7 @@ retry:
xfree(fenc);
}
if (fenc_next != NULL) {
fenc = (char *)next_fenc(&fenc_next, &fenc_alloced);
fenc = next_fenc(&fenc_next, &fenc_alloced);
} else {
fenc = "";
fenc_alloced = false;
@ -2068,25 +2068,25 @@ void set_forced_fenc(exarg_T *eap)
/// NULL.
/// When *pp is not set to NULL, the result is in allocated memory and "alloced"
/// is set to true.
static char_u *next_fenc(char **pp, bool *alloced)
static char *next_fenc(char **pp, bool *alloced)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET
{
char_u *p;
char_u *r;
char *p;
char *r;
*alloced = false;
if (**pp == NUL) {
*pp = NULL;
return (char_u *)"";
return "";
}
p = (char_u *)vim_strchr((*pp), ',');
p = vim_strchr((*pp), ',');
if (p == NULL) {
r = (char_u *)enc_canonize(*pp);
r = enc_canonize(*pp);
*pp += STRLEN(*pp);
} else {
r = vim_strnsave((char_u *)(*pp), (size_t)(p - (char_u *)(*pp)));
*pp = (char *)p + 1;
p = (char_u *)enc_canonize((char *)r);
r = xstrnsave(*pp, (size_t)(p - *pp));
*pp = p + 1;
p = enc_canonize(r);
xfree(r);
r = p;
}

4
src/nvim/getchar.c
View File

@ -2566,7 +2566,7 @@ static int vgetorpeek(bool advance)
// white-space, so find the last non-white
// character -- webb
curwin->w_wcol = 0;
ptr = get_cursor_line_ptr();
ptr = (char_u *)get_cursor_line_ptr();
chartabsize_T cts;
init_chartabsize_arg(&cts, curwin,
curwin->w_cursor.lnum, 0, (char *)ptr, (char *)ptr);
@ -2596,7 +2596,7 @@ static int vgetorpeek(bool advance)
if (col > 0 && curwin->w_wcol > 0) {
// Correct when the cursor is on the right halve
// of a double-wide character.
ptr = get_cursor_line_ptr();
ptr = (char_u *)get_cursor_line_ptr();
col -= utf_head_off((char *)ptr, (char *)ptr + col);
if (utf_ptr2cells((char *)ptr + col) > 1) {
curwin->w_wcol--;

2
src/nvim/grid.c
View File

@ -240,7 +240,7 @@ void grid_puts_len(ScreenGrid *grid, char *text, int textlen, int row, int col,
c = (unsigned char)(*ptr);
// check if this is the first byte of a multibyte
mbyte_blen = len > 0
? utfc_ptr2len_len((char_u *)ptr, (int)((text + len) - ptr))
? utfc_ptr2len_len(ptr, (int)((text + len) - ptr))
: utfc_ptr2len(ptr);
u8c = len >= 0
? utfc_ptr2char_len((char_u *)ptr, u8cc, (int)((text + len) - ptr))

10
src/nvim/indent.c
View File

@ -343,7 +343,7 @@ int get_sts_value(void)
// Count the size (in window cells) of the indent in the current line.
int get_indent(void)
{
return get_indent_str_vtab((char *)get_cursor_line_ptr(),
return get_indent_str_vtab(get_cursor_line_ptr(),
curbuf->b_p_ts,
curbuf->b_p_vts_array,
false);
@ -454,7 +454,7 @@ int set_indent(int size, int flags)
// characters needed for the indent.
todo = size;
ind_len = 0;
p = oldline = get_cursor_line_ptr();
p = oldline = (char_u *)get_cursor_line_ptr();
// Calculate the buffer size for the new indent, and check to see if it
// isn't already set.
@ -857,7 +857,7 @@ int inindent(int extra)
char_u *ptr;
colnr_T col;
for (col = 0, ptr = get_cursor_line_ptr(); ascii_iswhite(*ptr); col++) {
for (col = 0, ptr = (char_u *)get_cursor_line_ptr(); ascii_iswhite(*ptr); col++) {
ptr++;
}
@ -979,7 +979,7 @@ int get_lisp_indent(void)
continue;
}
for (that = get_cursor_line_ptr(); *that != NUL; that++) {
for (that = (char_u *)get_cursor_line_ptr(); *that != NUL; that++) {
if (*that == ';') {
while (*(that + 1) != NUL) {
that++;
@ -1029,7 +1029,7 @@ int get_lisp_indent(void)
curwin->w_cursor.col = pos->col;
col = pos->col;
that = get_cursor_line_ptr();
that = (char_u *)get_cursor_line_ptr();
if (vi_lisp && (get_indent() == 0)) {
amount = 2;

82
src/nvim/indent_c.c
View File

@ -355,7 +355,7 @@ static bool cin_islabel_skip(const char_u **s)
// Note: curwin->w_cursor must be where we are looking for the label.
bool cin_islabel(void) // XXX
{
const char_u *s = cin_skipcomment(get_cursor_line_ptr());
const char_u *s = cin_skipcomment((char_u *)get_cursor_line_ptr());
// Exclude "default" from labels, since it should be indented
// like a switch label. Same for C++ scope declarations.
@ -390,7 +390,7 @@ bool cin_islabel(void) // XXX
curwin->w_cursor = *trypos;
}
line = get_cursor_line_ptr();
line = (char_u *)get_cursor_line_ptr();
if (cin_ispreproc(line)) { // ignore #defines, #if, etc.
continue;
}
@ -421,7 +421,7 @@ static int cin_isinit(void)
const char_u *s;
static char *skip[] = { "static", "public", "protected", "private" };
s = cin_skipcomment(get_cursor_line_ptr());
s = cin_skipcomment((char_u *)get_cursor_line_ptr());
if (cin_starts_with(s, "typedef")) {
s = cin_skipcomment(s + 7);
@ -642,17 +642,17 @@ static int skip_label(linenr_T lnum, const char_u **pp)
cursor_save = curwin->w_cursor;
curwin->w_cursor.lnum = lnum;
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
// XXX
if (cin_iscase(l, false) || cin_isscopedecl(l) || cin_islabel()) {
amount = get_indent_nolabel(lnum);
l = after_label(get_cursor_line_ptr());
l = after_label((char_u *)get_cursor_line_ptr());
if (l == NULL) { // just in case
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
}
} else {
amount = get_indent();
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
}
*pp = l;
@ -674,7 +674,7 @@ static int cin_first_id_amount(void)
pos_T fp;
colnr_T col;
line = get_cursor_line_ptr();
line = (char_u *)get_cursor_line_ptr();
p = (char_u *)skipwhite((char *)line);
len = (int)((char_u *)skiptowhite((char *)p) - p);
if (len == 6 && STRNCMP(p, "static", 6) == 0) {
@ -1033,7 +1033,7 @@ static int cin_iswhileofdo(const char_u *p, linenr_T lnum) // XXX
cursor_save = curwin->w_cursor;
curwin->w_cursor.lnum = lnum;
curwin->w_cursor.col = 0;
p = get_cursor_line_ptr();
p = (char_u *)get_cursor_line_ptr();
while (*p && *p != 'w') { // skip any '}', until the 'w' of the "while"
p++;
curwin->w_cursor.col++;
@ -1110,7 +1110,7 @@ static int cin_iswhileofdo_end(int terminated)
return false;
}
p = line = get_cursor_line_ptr();
p = line = (char_u *)get_cursor_line_ptr();
while (*p != NUL) {
p = cin_skipcomment(p);
if (*p == ')') {
@ -1133,7 +1133,7 @@ static int cin_iswhileofdo_end(int terminated)
}
// Searching may have made "line" invalid, get it again.
line = get_cursor_line_ptr();
line = (char_u *)get_cursor_line_ptr();
p = line + i;
}
}
@ -1168,7 +1168,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
const char_u *s;
int class_or_struct, lookfor_ctor_init, cpp_base_class;
linenr_T lnum = curwin->w_cursor.lnum;
const char_u *line = get_cursor_line_ptr();
const char_u *line = (char_u *)get_cursor_line_ptr();
if (pos->lnum <= lnum) {
return cached->found; // Use the cached result
@ -1322,11 +1322,11 @@ static int get_baseclass_amount(int col)
if (col == 0) {
amount = get_indent();
if (find_last_paren(get_cursor_line_ptr(), '(', ')')
if (find_last_paren((char_u *)get_cursor_line_ptr(), '(', ')')
&& (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL) {
amount = get_indent_lnum(trypos->lnum); // XXX
}
if (!cin_ends_in(get_cursor_line_ptr(), (char_u *)",", NULL)) {
if (!cin_ends_in((char_u *)get_cursor_line_ptr(), (char_u *)",", NULL)) {
amount += curbuf->b_ind_cpp_baseclass;
}
} else {
@ -2287,7 +2287,7 @@ int get_c_indent(void)
/* Ignore a '(' in front of the line that has a match before
* our matching '('. */
curwin->w_cursor.lnum = our_paren_pos.lnum;
line = get_cursor_line_ptr();
line = (char_u *)get_cursor_line_ptr();
look_col = (int)(look - line);
curwin->w_cursor.col = look_col + 1;
if ((trypos = findmatchlimit(NULL, ')', 0,
@ -2472,7 +2472,7 @@ int get_c_indent(void)
// ldfd) {
// }
if ((curbuf->b_ind_js || curbuf->b_ind_keep_case_label)
&& cin_iscase((char_u *)skipwhite((char *)get_cursor_line_ptr()), false)) {
&& cin_iscase((char_u *)skipwhite(get_cursor_line_ptr()), false)) {
amount = get_indent();
} else if (curbuf->b_ind_js) {
amount = get_indent_lnum(lnum);
@ -2539,7 +2539,7 @@ int get_c_indent(void)
if (start_brace == BRACE_AT_END) { // '{' is at end of line
amount += curbuf->b_ind_open_imag;
l = (char_u *)skipwhite((char *)get_cursor_line_ptr());
l = (char_u *)skipwhite(get_cursor_line_ptr());
if (cin_is_cpp_namespace(l)) {
amount += curbuf->b_ind_cpp_namespace;
} else if (cin_is_cpp_extern_c(l)) {
@ -2614,7 +2614,7 @@ int get_c_indent(void)
break;
}
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
/*
* If we're in a comment or raw string now, skip to
@ -2734,7 +2734,7 @@ int get_c_indent(void)
break;
}
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
/* If we're in a comment or raw string now, skip
* to the start of it. */
@ -2777,7 +2777,7 @@ int get_c_indent(void)
continue;
}
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
/*
* If this is a switch() label, may line up relative to that.
@ -2853,7 +2853,7 @@ int get_c_indent(void)
// -> y = y + 1;
if (n) {
amount = n;
l = after_label(get_cursor_line_ptr());
l = after_label((char_u *)get_cursor_line_ptr());
if (l != NULL && cin_is_cinword((char *)l)) {
if (theline[0] == '{') {
amount += curbuf->b_ind_open_extra;
@ -2898,7 +2898,7 @@ int get_c_indent(void)
* Ignore jump labels with nothing after them.
*/
if (!curbuf->b_ind_js && cin_islabel()) {
l = after_label(get_cursor_line_ptr());
l = after_label((char_u *)get_cursor_line_ptr());
if (l == NULL || cin_nocode(l)) {
continue;
}
@ -2910,7 +2910,7 @@ int get_c_indent(void)
* (need to get the line again, cin_islabel() may have
* unlocked it)
*/
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum, &amount)
|| cin_nocode(l)) {
continue;
@ -2922,7 +2922,7 @@ int get_c_indent(void)
n = 0;
if (lookfor != LOOKFOR_TERM && curbuf->b_ind_cpp_baseclass > 0) {
n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
}
if (n) {
if (lookfor == LOOKFOR_UNTERM) {
@ -3039,7 +3039,7 @@ int get_c_indent(void)
* asdf)
*/
curwin->w_cursor = *trypos;
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
if (cin_iscase(l, false) || cin_isscopedecl(l)) {
curwin->w_cursor.lnum++;
curwin->w_cursor.col = 0;
@ -3154,7 +3154,7 @@ int get_c_indent(void)
* x = 1;
* -> here
*/
l = (char_u *)skipwhite((char *)get_cursor_line_ptr());
l = (char_u *)skipwhite(get_cursor_line_ptr());
if (cin_isdo(l)) {
if (whilelevel == 0) {
break;
@ -3174,7 +3174,7 @@ int get_c_indent(void)
* not the one from "if () {". */
if (*l == '}') {
curwin->w_cursor.col =
(colnr_T)(l - get_cursor_line_ptr()) + 1;
(colnr_T)(l - (char_u *)get_cursor_line_ptr()) + 1;
}
if ((trypos = find_start_brace()) == NULL
@ -3231,7 +3231,7 @@ int get_c_indent(void)
// line up with this line, remember its indent
// 100 + // NOLINT(whitespace/tab)
// -> here; // NOLINT(whitespace/tab)
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
amount = cur_amount;
n = (int)STRLEN(l);
@ -3341,7 +3341,7 @@ int get_c_indent(void)
* may be lined up with the case label.
*/
if (lookfor == LOOKFOR_NOBREAK
&& cin_isbreak((char_u *)skipwhite((char *)get_cursor_line_ptr()))) {
&& cin_isbreak((char_u *)skipwhite(get_cursor_line_ptr()))) {
lookfor = LOOKFOR_ANY;
continue;
}
@ -3350,7 +3350,7 @@ int get_c_indent(void)
* Handle "do {" line.
*/
if (whilelevel > 0) {
l = cin_skipcomment(get_cursor_line_ptr());
l = cin_skipcomment((char_u *)get_cursor_line_ptr());
if (cin_isdo(l)) {
amount = get_indent(); // XXX
whilelevel--;
@ -3408,7 +3408,7 @@ int get_c_indent(void)
* here;
*/
term_again:
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
if (find_last_paren(l, '(', ')')
&& (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL) {
// Check if we are on a case label now. This is
@ -3416,7 +3416,7 @@ term_again:
// case xx: if ( asdf &&
// asdf)
curwin->w_cursor = *trypos;
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
if (cin_iscase(l, false) || cin_isscopedecl(l)) {
curwin->w_cursor.lnum++;
curwin->w_cursor.col = 0;
@ -3475,13 +3475,13 @@ term_again:
* If we're at the end of a block, skip to the start of
* that block.
*/
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
if (find_last_paren(l, '{', '}') // XXX
&& (trypos = find_start_brace()) != NULL) {
curwin->w_cursor = *trypos;
// if not "else {" check for terminated again
// but skip block for "} else {"
l = cin_skipcomment(get_cursor_line_ptr());
l = cin_skipcomment((char_u *)get_cursor_line_ptr());
if (*l == '}' || !cin_iselse(l)) {
goto term_again;
}
@ -3547,7 +3547,7 @@ term_again:
curwin->w_cursor.lnum--;
curwin->w_cursor.col = 0;
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
// If we're in a comment or raw string now, skip to the start
// of it.
@ -3563,7 +3563,7 @@ term_again:
n = 0;
if (curbuf->b_ind_cpp_baseclass != 0) {
n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
}
if (n) {
// XXX
@ -3635,7 +3635,7 @@ term_again:
if (cin_isfuncdecl(NULL, cur_curpos.lnum, 0)) { // XXX
break;
}
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
/*
* Finding the closing '}' of a previous function. Put
@ -3709,7 +3709,7 @@ term_again:
|| (*l != NUL && l[STRLEN(l) - 1] == '\\')) {
break;
}
l = get_cursor_line_ptr();
l = (char_u *)get_cursor_line_ptr();
}
/*
@ -3786,7 +3786,7 @@ static int find_match(int lookfor, linenr_T ourscope)
curwin->w_cursor.lnum--;
curwin->w_cursor.col = 0;
look = cin_skipcomment(get_cursor_line_ptr());
look = cin_skipcomment((char_u *)get_cursor_line_ptr());
if (!cin_iselse(look)
&& !cin_isif(look)
&& !cin_isdo(look) // XXX
@ -3826,7 +3826,7 @@ static int find_match(int lookfor, linenr_T ourscope)
* then we need to go back to another if, so
* increment elselevel
*/
look = cin_skipcomment(get_cursor_line_ptr());
look = cin_skipcomment((char_u *)get_cursor_line_ptr());
if (cin_iselse(look)) {
mightbeif = cin_skipcomment(look + 4);
if (!cin_isif(mightbeif)) {
@ -3845,7 +3845,7 @@ static int find_match(int lookfor, linenr_T ourscope)
}
// If it's an "if" decrement elselevel
look = cin_skipcomment(get_cursor_line_ptr());
look = cin_skipcomment((char_u *)get_cursor_line_ptr());
if (cin_isif(look)) {
elselevel--;
/*

116
src/nvim/insexpand.c
View File

@ -231,7 +231,7 @@ static pos_T compl_startpos;
static int compl_length = 0;
static colnr_T compl_col = 0; ///< column where the text starts
///< that is being completed
static char_u *compl_orig_text = NULL; ///< text as it was before
static char *compl_orig_text = NULL; ///< text as it was before
///< completion started
static int compl_cont_mode = 0;
static expand_T compl_xp;
@ -587,7 +587,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
// Rule 1: Were any chars converted to lower?
{
const char_u *p = compl_orig_text;
const char_u *p = (char_u *)compl_orig_text;
for (int i = 0; i < min_len; i++) {
const int c = mb_ptr2char_adv(&p);
if (mb_islower(c)) {
@ -606,7 +606,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
// Rule 2: No lower case, 2nd consecutive letter converted to
// upper case.
if (!has_lower) {
const char_u *p = compl_orig_text;
const char_u *p = (char_u *)compl_orig_text;
for (int i = 0; i < min_len; i++) {
const int c = mb_ptr2char_adv(&p);
if (was_letter && mb_isupper(c) && mb_islower(wca[i])) {
@ -622,7 +622,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
// Copy the original case of the part we typed.
{
const char_u *p = compl_orig_text;
const char_u *p = (char_u *)compl_orig_text;
for (int i = 0; i < min_len; i++) {
const int c = mb_ptr2char_adv(&p);
if (mb_islower(c)) {
@ -699,7 +699,7 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
// Find actual length of original text.
{
const char_u *p = compl_orig_text;
const char_u *p = (char_u *)compl_orig_text;
compl_char_len = 0;
while (*p != NUL) {
MB_PTR_ADV(p);
@ -720,7 +720,7 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
flags |= CP_ICASE;
}
int res = ins_compl_add(str, len, fname, NULL, false, NULL, dir, flags, false);
int res = ins_compl_add((char *)str, len, (char *)fname, NULL, false, NULL, dir, flags, false);
xfree(tofree);
return res;
}
@ -748,9 +748,9 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
/// @return NOTDONE if the given string is already in the list of completions,
/// otherwise it is added to the list and OK is returned. FAIL will be
/// returned in case of error.
static int ins_compl_add(char_u *const str, int len, char_u *const fname,
char_u *const *const cptext, const bool cptext_allocated,
typval_T *user_data, const Direction cdir, int flags_arg, const bool adup)
static int ins_compl_add(char *const str, int len, char *const fname, char *const *const cptext,
const bool cptext_allocated, typval_T *user_data, const Direction cdir,
int flags_arg, const bool adup)
FUNC_ATTR_NONNULL_ARG(1)
{
compl_T *match;
@ -802,7 +802,7 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
if (flags & CP_ORIGINAL_TEXT) {
match->cp_number = 0;
}
match->cp_str = vim_strnsave(str, (size_t)len);
match->cp_str = (char_u *)xstrnsave(str, (size_t)len);
// match-fname is:
// - compl_curr_match->cp_fname if it is a string equal to fname.
@ -814,7 +814,7 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
&& STRCMP(fname, compl_curr_match->cp_fname) == 0) {
match->cp_fname = compl_curr_match->cp_fname;
} else if (fname != NULL) {
match->cp_fname = vim_strsave(fname);
match->cp_fname = vim_strsave((char_u *)fname);
flags |= CP_FREE_FNAME;
} else {
match->cp_fname = NULL;
@ -830,8 +830,8 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
}
if (*cptext[i] != NUL) {
match->cp_text[i] = (cptext_allocated
? cptext[i]
: (char_u *)xstrdup((char *)cptext[i]));
? (char_u *)cptext[i]
: (char_u *)xstrdup(cptext[i]));
} else if (cptext_allocated) {
xfree(cptext[i]);
}
@ -957,7 +957,7 @@ static void ins_compl_add_matches(int num_matches, char **matches, int icase)
Direction dir = compl_direction;
for (int i = 0; i < num_matches && add_r != FAIL; i++) {
if ((add_r = ins_compl_add((char_u *)matches[i], -1, NULL, NULL, false, NULL, dir,
if ((add_r = ins_compl_add(matches[i], -1, NULL, NULL, false, NULL, dir,
CP_FAST | (icase ? CP_ICASE : 0),
false)) == OK) {
// If dir was BACKWARD then honor it just once.
@ -1621,8 +1621,8 @@ int ins_compl_len(void)
/// to be got from the user.
int ins_compl_bs(void)
{
char_u *line = get_cursor_line_ptr();
char_u *p = line + curwin->w_cursor.col;
char *line = get_cursor_line_ptr();
char *p = line + curwin->w_cursor.col;
MB_PTR_BACK(line, p);
ptrdiff_t p_off = p - line;
@ -1649,7 +1649,7 @@ int ins_compl_bs(void)
line = get_cursor_line_ptr();
xfree(compl_leader);
compl_leader = vim_strnsave(line + compl_col, (size_t)(p_off - (ptrdiff_t)compl_col));
compl_leader = (char_u *)xstrnsave(line + compl_col, (size_t)(p_off - (ptrdiff_t)compl_col));
ins_compl_new_leader();
if (compl_shown_match != NULL) {
@ -1743,7 +1743,7 @@ void ins_compl_addleader(int c)
}
xfree(compl_leader);
compl_leader = vim_strnsave(get_cursor_line_ptr() + compl_col,
compl_leader = (char_u *)xstrnsave(get_cursor_line_ptr() + compl_col,
(size_t)(curwin->w_cursor.col - compl_col));
ins_compl_new_leader();
}
@ -2008,7 +2008,7 @@ static bool ins_compl_stop(const int c, const int prev_mode, bool retval)
if (compl_leader != NULL) {
p = compl_leader;
} else if (compl_first_match != NULL) {
p = compl_orig_text;
p = (char_u *)compl_orig_text;
}
if (p != NULL) {
const int compl_len = get_compl_len();
@ -2174,7 +2174,7 @@ static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg)
}
}
if (compl_orig_text != NULL) {
p = compl_orig_text;
p = (char_u *)compl_orig_text;
for (len = 0; p[len] != NUL && p[len] == ptr[len]; len++) {}
if (len > 0) {
len -= utf_head_off((char *)p, (char *)p + len);
@ -2360,7 +2360,7 @@ static int ins_compl_add_tv(typval_T *const tv, const Direction dir, bool fast)
tv_clear(&user_data);
return FAIL;
}
int status = ins_compl_add((char_u *)word, -1, NULL, (char_u **)cptext, true,
int status = ins_compl_add((char *)word, -1, NULL, cptext, true,
&user_data, dir, flags, dup);
if (status != OK) {
tv_clear(&user_data);
@ -2430,7 +2430,7 @@ static void set_completion(colnr_T startcol, list_T *list)
compl_col = startcol;
compl_length = (int)curwin->w_cursor.col - (int)startcol;
// compl_pattern doesn't need to be set
compl_orig_text = vim_strnsave(get_cursor_line_ptr() + compl_col,
compl_orig_text = xstrnsave(get_cursor_line_ptr() + compl_col,
(size_t)compl_length);
if (p_ic) {
flags |= CP_ICASE;
@ -3513,7 +3513,7 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
// Insert the text of the new completion, or the compl_leader.
if (compl_no_insert && !started) {
ins_bytes((char *)compl_orig_text + get_compl_len());
ins_bytes(compl_orig_text + get_compl_len());
compl_used_match = false;
} else if (insert_match) {
if (!compl_get_longest || compl_used_match) {
@ -3697,7 +3697,7 @@ static bool ins_compl_use_match(int c)
/// completion)
/// Sets the global variables: compl_col, compl_length and compl_pattern.
/// Uses the global variables: compl_cont_status and ctrl_x_mode
static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
static int get_normal_compl_info(char *line, int startcol, colnr_T curs_col)
{
if ((compl_cont_status & CONT_SOL) || ctrl_x_mode_path_defines()) {
if (!compl_status_adding()) {
@ -3706,25 +3706,25 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
compl_length = curs_col - startcol;
}
if (p_ic) {
compl_pattern = (char *)str_foldcase(line + compl_col, compl_length, NULL, 0);
compl_pattern = (char *)str_foldcase((char_u *)line + compl_col, compl_length, NULL, 0);
} else {
compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
}
} else if (compl_status_adding()) {
char_u *prefix = (char_u *)"\\<";
// we need up to 2 extra chars for the prefix
compl_pattern = xmalloc(quote_meta(NULL, line + compl_col,
compl_length) + 2);
if (!vim_iswordp(line + compl_col)
|| (compl_col > 0 && (vim_iswordp(mb_prevptr(line, line + compl_col))))) {
compl_pattern = xmalloc(quote_meta(NULL, (char_u *)line + compl_col, compl_length) + 2);
if (!vim_iswordp((char_u *)line + compl_col)
|| (compl_col > 0
&& (vim_iswordp(mb_prevptr((char_u *)line, (char_u *)line + compl_col))))) {
prefix = (char_u *)"";
}
STRCPY(compl_pattern, prefix);
(void)quote_meta((char_u *)compl_pattern + STRLEN(prefix),
line + compl_col, compl_length);
(char_u *)line + compl_col, compl_length);
} else if (--startcol < 0
|| !vim_iswordp(mb_prevptr(line, line + startcol + 1))) {
|| !vim_iswordp(mb_prevptr((char_u *)line, (char_u *)line + startcol + 1))) {
// Match any word of at least two chars
compl_pattern = xstrdup("\\<\\k\\k");
compl_col += curs_col;
@ -3732,11 +3732,11 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
} else {
// Search the point of change class of multibyte character
// or not a word single byte character backward.
startcol -= utf_head_off((char *)line, (char *)line + startcol);
int base_class = mb_get_class(line + startcol);
startcol -= utf_head_off(line, line + startcol);
int base_class = mb_get_class((char_u *)line + startcol);
while (--startcol >= 0) {
int head_off = utf_head_off((char *)line, (char *)line + startcol);
if (base_class != mb_get_class(line + startcol - head_off)) {
int head_off = utf_head_off(line, line + startcol);
if (base_class != mb_get_class((char_u *)line + startcol - head_off)) {
break;
}
startcol -= head_off;
@ -3749,13 +3749,13 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
// xmalloc(7) is enough -- Acevedo
compl_pattern = xmalloc(7);
STRCPY(compl_pattern, "\\<");
(void)quote_meta((char_u *)compl_pattern + 2, line + compl_col, 1);
(void)quote_meta((char_u *)compl_pattern + 2, (char_u *)line + compl_col, 1);
STRCAT(compl_pattern, "\\k");
} else {
compl_pattern = xmalloc(quote_meta(NULL, line + compl_col,
compl_pattern = xmalloc(quote_meta(NULL, (char_u *)line + compl_col,
compl_length) + 2);
STRCPY(compl_pattern, "\\<");
(void)quote_meta((char_u *)compl_pattern + 2, line + compl_col, compl_length);
(void)quote_meta((char_u *)compl_pattern + 2, (char_u *)line + compl_col, compl_length);
}
}
@ -3765,17 +3765,17 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
/// Get the pattern, column and length for whole line completion or for the
/// complete() function.
/// Sets the global variables: compl_col, compl_length and compl_pattern.
static int get_wholeline_compl_info(char_u *line, colnr_T curs_col)
static int get_wholeline_compl_info(char *line, colnr_T curs_col)
{
compl_col = (colnr_T)getwhitecols((char *)line);
compl_col = (colnr_T)getwhitecols(line);
compl_length = (int)curs_col - (int)compl_col;
if (compl_length < 0) { // cursor in indent: empty pattern
compl_length = 0;
}
if (p_ic) {
compl_pattern = (char *)str_foldcase(line + compl_col, compl_length, NULL, 0);
compl_pattern = (char *)str_foldcase((char_u *)line + compl_col, compl_length, NULL, 0);
} else {
compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
}
return OK;
@ -3802,16 +3802,16 @@ static int get_filename_compl_info(char_u *line, int startcol, colnr_T curs_col)
compl_col += startcol;
compl_length = (int)curs_col - startcol;
compl_pattern = (char *)addstar(line + compl_col, (size_t)compl_length, EXPAND_FILES);
compl_pattern = addstar((char *)line + compl_col, (size_t)compl_length, EXPAND_FILES);
return OK;
}
/// Get the pattern, column and length for command-line completion.
/// Sets the global variables: compl_col, compl_length and compl_pattern.
static int get_cmdline_compl_info(char_u *line, colnr_T curs_col)
static int get_cmdline_compl_info(char *line, colnr_T curs_col)
{
compl_pattern = (char *)vim_strnsave(line, (size_t)curs_col);
compl_pattern = xstrnsave(line, (size_t)curs_col);
set_cmd_context(&compl_xp, (char_u *)compl_pattern, (int)STRLEN(compl_pattern), curs_col, false);
if (compl_xp.xp_context == EXPAND_UNSUCCESSFUL
|| compl_xp.xp_context == EXPAND_NOTHING) {
@ -3893,9 +3893,9 @@ static int get_userdefined_compl_info(colnr_T curs_col)
// Setup variables for completion. Need to obtain "line" again,
// it may have become invalid.
char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
char *line = ml_get(curwin->w_cursor.lnum);
compl_length = curs_col - compl_col;
compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
return OK;
}
@ -3919,8 +3919,8 @@ static int get_spell_compl_info(int startcol, colnr_T curs_col)
compl_length = (int)curs_col - compl_col;
}
// Need to obtain "line" again, it may have become invalid.
char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
char *line = ml_get(curwin->w_cursor.lnum);
compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
return OK;
}
@ -3939,13 +3939,13 @@ static int compl_get_info(char_u *line, int startcol, colnr_T curs_col, bool *li
if (ctrl_x_mode_normal()
|| ((ctrl_x_mode & CTRL_X_WANT_IDENT)
&& !thesaurus_func_complete(ctrl_x_mode))) {
return get_normal_compl_info(line, startcol, curs_col);
return get_normal_compl_info((char *)line, startcol, curs_col);
} else if (ctrl_x_mode_line_or_eval()) {
return get_wholeline_compl_info(line, curs_col);
return get_wholeline_compl_info((char *)line, curs_col);
} else if (ctrl_x_mode_files()) {
return get_filename_compl_info(line, startcol, curs_col);
} else if (ctrl_x_mode == CTRL_X_CMDLINE) {
return get_cmdline_compl_info(line, curs_col);
return get_cmdline_compl_info((char *)line, curs_col);
} else if (ctrl_x_mode_function() || ctrl_x_mode_omni()
|| thesaurus_func_complete(ctrl_x_mode)) {
if (get_userdefined_compl_info(curs_col) == FAIL) {
@ -4036,7 +4036,7 @@ static int ins_compl_start(void)
return FAIL;
}
char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
char *line = ml_get(curwin->w_cursor.lnum);
colnr_T curs_col = curwin->w_cursor.col;
compl_pending = 0;
@ -4044,7 +4044,7 @@ static int ins_compl_start(void)
&& compl_cont_mode == ctrl_x_mode) {
// this same ctrl-x_mode was interrupted previously. Continue the
// completion.
ins_compl_continue_search(line);
ins_compl_continue_search((char_u *)line);
} else {
compl_cont_status &= CONT_LOCAL;
}
@ -4064,7 +4064,7 @@ static int ins_compl_start(void)
// Work out completion pattern and original text -- webb
bool line_invalid = false;
if (compl_get_info(line, startcol, curs_col, &line_invalid) == FAIL) {
if (compl_get_info((char_u *)line, startcol, curs_col, &line_invalid) == FAIL) {
if (ctrl_x_mode_function() || ctrl_x_mode_omni()
|| thesaurus_func_complete(ctrl_x_mode)) {
// restore did_ai, so that adding comment leader works
@ -4074,7 +4074,7 @@ static int ins_compl_start(void)
}
// If "line" was changed while getting completion info get it again.
if (line_invalid) {
line = (char_u *)ml_get(curwin->w_cursor.lnum);
line = ml_get(curwin->w_cursor.lnum);
}
if (compl_status_adding()) {
@ -4108,7 +4108,7 @@ static int ins_compl_start(void)
// Always add completion for the original text.
xfree(compl_orig_text);
compl_orig_text = vim_strnsave(line + compl_col, (size_t)compl_length);
compl_orig_text = xstrnsave(line + compl_col, (size_t)compl_length);
int flags = CP_ORIGINAL_TEXT;
if (p_ic) {
flags |= CP_ICASE;

8
src/nvim/keycodes.c
View File

@ -650,7 +650,7 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
if (*bp == '-') {
last_dash = bp;
if (bp + 1 <= end) {
l = utfc_ptr2len_len(bp + 1, (int)(end - bp) + 1);
l = utfc_ptr2len_len((char *)bp + 1, (int)(end - bp) + 1);
// Anything accepted, like <C-?>.
// <C-"> or <M-"> are not special in strings as " is
// the string delimiter. With a backslash it works: <M-\">
@ -665,7 +665,7 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
if (end - bp > 3 && bp[0] == 't' && bp[1] == '_') {
bp += 3; // skip t_xx, xx may be '-' or '>'
} else if (end - bp > 4 && STRNICMP(bp, "char-", 5) == 0) {
vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0, true);
vim_str2nr((char *)bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0, true);
if (l == 0) {
emsg(_(e_invarg));
return 0;
@ -695,7 +695,7 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
if (STRNICMP(last_dash + 1, "char-", 5) == 0
&& ascii_isdigit(last_dash[6])) {
// <Char-123> or <Char-033> or <Char-0x33>
vim_str2nr(last_dash + 6, NULL, &l, STR2NR_ALL, NULL, &n, 0, true);
vim_str2nr((char *)last_dash + 6, NULL, &l, STR2NR_ALL, NULL, &n, 0, true);
if (l == 0) {
emsg(_(e_invarg));
return 0;
@ -993,7 +993,7 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
}
// skip multibyte char correctly
for (i = utfc_ptr2len_len(src, (int)(end - src) + 1); i > 0; i--) {
for (i = utfc_ptr2len_len((char *)src, (int)(end - src) + 1); i > 0; i--) {
// If the character is K_SPECIAL, replace it with K_SPECIAL
// KS_SPECIAL KE_FILLER.
if (*src == K_SPECIAL) {

22
src/nvim/mark.c
View File

@ -800,31 +800,29 @@ void clrallmarks(buf_T *const buf)
char_u *fm_getname(fmark_T *fmark, int lead_len)
{
if (fmark->fnum == curbuf->b_fnum) { // current buffer
return mark_line(&(fmark->mark), lead_len);
return (char_u *)mark_line(&(fmark->mark), lead_len);
}
return (char_u *)buflist_nr2name(fmark->fnum, false, true);
}
/*
* Return the line at mark "mp". Truncate to fit in window.
* The returned string has been allocated.
*/
static char_u *mark_line(pos_T *mp, int lead_len)
/// Return the line at mark "mp". Truncate to fit in window.
/// The returned string has been allocated.
static char *mark_line(pos_T *mp, int lead_len)
{
char_u *s, *p;
char *s, *p;
int len;
if (mp->lnum == 0 || mp->lnum > curbuf->b_ml.ml_line_count) {
return vim_strsave((char_u *)"-invalid-");
return xstrdup("-invalid-");
}
assert(Columns >= 0);
// Allow for up to 5 bytes per character.
s = vim_strnsave((char_u *)skipwhite(ml_get(mp->lnum)), (size_t)Columns * 5);
s = xstrnsave(skipwhite(ml_get(mp->lnum)), (size_t)Columns * 5);
// Truncate the line to fit it in the window
len = 0;
for (p = s; *p != NUL; MB_PTR_ADV(p)) {
len += ptr2cells((char *)p);
len += ptr2cells(p);
if (len >= Columns - lead_len) {
break;
}
@ -908,7 +906,7 @@ static void show_one_mark(int c, char_u *arg, pos_T *p, char_u *name_arg, int cu
&& p->lnum != 0) {
// don't output anything if 'q' typed at --more-- prompt
if (name == NULL && current) {
name = mark_line(p, 15);
name = (char_u *)mark_line(p, 15);
mustfree = true;
}
if (!message_filtered((char *)name)) {
@ -1094,7 +1092,7 @@ void ex_changes(exarg_T *eap)
(long)curbuf->b_changelist[i].mark.lnum,
curbuf->b_changelist[i].mark.col);
msg_outtrans((char *)IObuff);
name = mark_line(&curbuf->b_changelist[i].mark, 17);
name = (char_u *)mark_line(&curbuf->b_changelist[i].mark, 17);
msg_outtrans_attr((char *)name, HL_ATTR(HLF_D));
xfree(name);
os_breakcheck();

26
src/nvim/match.c
View File

@ -1159,9 +1159,9 @@ void f_matchdelete(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
/// skipping commands to find the next command.
void ex_match(exarg_T *eap)
{
char_u *p;
char_u *g = NULL;
char_u *end;
char *p;
char *g = NULL;
char *end;
int c;
int id;
@ -1178,25 +1178,25 @@ void ex_match(exarg_T *eap)
}
if (ends_excmd(*eap->arg)) {
end = (char_u *)eap->arg;
end = eap->arg;
} else if ((STRNICMP(eap->arg, "none", 4) == 0
&& (ascii_iswhite(eap->arg[4]) || ends_excmd(eap->arg[4])))) {
end = (char_u *)eap->arg + 4;
end = eap->arg + 4;
} else {
p = (char_u *)skiptowhite(eap->arg);
p = skiptowhite(eap->arg);
if (!eap->skip) {
g = vim_strnsave((char_u *)eap->arg, (size_t)(p - (char_u *)eap->arg));
g = xstrnsave(eap->arg, (size_t)(p - eap->arg));
}
p = (char_u *)skipwhite((char *)p);
p = skipwhite(p);
if (*p == NUL) {
// There must be two arguments.
xfree(g);
semsg(_(e_invarg2), eap->arg);
return;
}
end = (char_u *)skip_regexp((char *)p + 1, *p, true, NULL);
end = skip_regexp(p + 1, *p, true, NULL);
if (!eap->skip) {
if (*end != NUL && !ends_excmd(*skipwhite((char *)end + 1))) {
if (*end != NUL && !ends_excmd(*skipwhite(end + 1))) {
xfree(g);
eap->errmsg = ex_errmsg(e_trailing_arg, (const char *)end);
return;
@ -1207,13 +1207,13 @@ void ex_match(exarg_T *eap)
return;
}
c = *end;
c = (uint8_t)(*end);
*end = NUL;
match_add(curwin, (const char *)g, (const char *)p + 1, 10, id,
NULL, NULL);
xfree(g);
*end = (char_u)c;
*end = (char)c;
}
}
eap->nextcmd = find_nextcmd((char *)end);
eap->nextcmd = find_nextcmd(end);
}

42
src/nvim/mbyte.c
View File

@ -587,7 +587,7 @@ size_t mb_string2cells_len(const char *str, size_t size)
size_t clen = 0;
for (const char_u *p = (char_u *)str; *p != NUL && p < (char_u *)str + size;
p += utfc_ptr2len_len(p, (int)size + (int)(p - (char_u *)str))) {
p += utfc_ptr2len_len((char *)p, (int)size + (int)(p - (char_u *)str))) {
clen += (size_t)utf_ptr2cells((char *)p);
}
@ -727,12 +727,10 @@ int mb_cptr2char_adv(const char_u **pp)
return c;
}
/*
* Check if the character pointed to by "p2" is a composing character when it
* comes after "p1". For Arabic sometimes "ab" is replaced with "c", which
* behaves like a composing character.
*/
bool utf_composinglike(const char_u *p1, const char_u *p2)
/// Check if the character pointed to by "p2" is a composing character when it
/// comes after "p1". For Arabic sometimes "ab" is replaced with "c", which
/// behaves like a composing character.
bool utf_composinglike(const char *p1, const char *p2)
{
int c2;
@ -765,7 +763,7 @@ int utfc_ptr2char(const char *p_in, int *pcc)
// Only accept a composing char when the first char isn't illegal.
if ((len > 1 || *p < 0x80)
&& p[len] >= 0x80
&& utf_composinglike(p, p + len)) {
&& utf_composinglike((char *)p, (char *)p + len)) {
int cc = utf_ptr2char((char *)p + len);
for (;;) {
pcc[i++] = cc;
@ -809,7 +807,7 @@ int utfc_ptr2char_len(const char_u *p, int *pcc, int maxlen)
int len_cc = utf_ptr2len_len(p + len, maxlen - len);
safe = len_cc > 1 && len_cc <= maxlen - len;
if (!safe || (pcc[i] = utf_ptr2char((char *)p + len)) < 0x80
|| !(i == 0 ? utf_composinglike(p, p + len) : utf_iscomposing(pcc[i]))) {
|| !(i == 0 ? utf_composinglike((char *)p, (char *)p + len) : utf_iscomposing(pcc[i]))) {
break;
}
len += len_cc;
@ -916,7 +914,7 @@ int utfc_ptr2len(const char *const p_in)
// skip all of them (otherwise the cursor would get stuck).
int prevlen = 0;
for (;;) {
if (p[len] < 0x80 || !utf_composinglike(p + prevlen, p + len)) {
if (p[len] < 0x80 || !utf_composinglike((char *)p + prevlen, (char *)p + len)) {
return len;
}
@ -926,13 +924,11 @@ int utfc_ptr2len(const char *const p_in)
}
}
/*
* Return the number of bytes the UTF-8 encoding of the character at "p[size]"
* takes. This includes following composing characters.
* Returns 0 for an empty string.
* Returns 1 for an illegal char or an incomplete byte sequence.
*/
int utfc_ptr2len_len(const char_u *p, int size)
/// Return the number of bytes the UTF-8 encoding of the character at "p[size]"
/// takes. This includes following composing characters.
/// Returns 0 for an empty string.
/// Returns 1 for an illegal char or an incomplete byte sequence.
int utfc_ptr2len_len(const char *p, int size)
{
int len;
int prevlen;
@ -940,15 +936,15 @@ int utfc_ptr2len_len(const char_u *p, int size)
if (size < 1 || *p == NUL) {
return 0;
}
if (p[0] < 0x80 && (size == 1 || p[1] < 0x80)) { // be quick for ASCII
if ((uint8_t)p[0] < 0x80 && (size == 1 || (uint8_t)p[1] < 0x80)) { // be quick for ASCII
return 1;
}
// Skip over first UTF-8 char, stopping at a NUL byte.
len = utf_ptr2len_len(p, size);
len = utf_ptr2len_len((char_u *)p, size);
// Check for illegal byte and incomplete byte sequence.
if ((len == 1 && p[0] >= 0x80) || len > size) {
if ((len == 1 && (uint8_t)p[0] >= 0x80) || len > size) {
return 1;
}
@ -960,7 +956,7 @@ int utfc_ptr2len_len(const char_u *p, int size)
while (len < size) {
int len_next_char;
if (p[len] < 0x80) {
if ((uint8_t)p[len] < 0x80) {
break;
}
@ -968,7 +964,7 @@ int utfc_ptr2len_len(const char_u *p, int size)
* Next character length should not go beyond size to ensure that
* utf_composinglike(...) does not read beyond size.
*/
len_next_char = utf_ptr2len_len(p + len, size - len);
len_next_char = utf_ptr2len_len((char_u *)p + len, size - len);
if (len_next_char > size - len) {
break;
}
@ -2420,7 +2416,7 @@ static char_u *iconv_string(const vimconv_T *const vcp, char_u *str, size_t slen
if (utf_ptr2cells(from) > 1) {
*to++ = '?';
}
l = utfc_ptr2len_len((const char_u *)from, (int)fromlen);
l = utfc_ptr2len_len(from, (int)fromlen);
from += l;
fromlen -= (size_t)l;
} else if (ICONV_ERRNO != ICONV_E2BIG) {

38
src/nvim/memline.c
View File

@ -735,12 +735,12 @@ void ml_recover(bool checkext)
{
buf_T *buf = NULL;
memfile_T *mfp = NULL;
char_u *fname;
char_u *fname_used = NULL;
char *fname;
char *fname_used = NULL;
bhdr_T *hp = NULL;
ZERO_BL *b0p;
int b0_ff;
char_u *b0_fenc = NULL;
char *b0_fenc = NULL;
PTR_BL *pp;
DATA_BL *dp;
infoptr_T *ip;
@ -748,7 +748,7 @@ void ml_recover(bool checkext)
int len;
bool directly;
linenr_T lnum;
char_u *p;
char *p;
int i;
long error;
bool cannot_open;
@ -770,9 +770,9 @@ void ml_recover(bool checkext)
// If the file name ends in ".s[a-w][a-z]" we assume this is the swap file.
// Otherwise a search is done to find the swap file(s).
fname = (char_u *)curbuf->b_fname;
fname = curbuf->b_fname;
if (fname == NULL) { // When there is no file name
fname = (char_u *)"";
fname = "";
}
len = (int)STRLEN(fname);
if (checkext && len >= 4
@ -780,12 +780,12 @@ void ml_recover(bool checkext)
&& vim_strchr("abcdefghijklmnopqrstuvw", TOLOWER_ASC(fname[len - 2])) != NULL
&& ASCII_ISALPHA(fname[len - 1])) {
directly = true;
fname_used = vim_strsave(fname); // make a copy for mf_open()
fname_used = xstrdup(fname); // make a copy for mf_open()
} else {
directly = false;
// count the number of matching swap files
len = recover_names(fname, false, 0, NULL);
len = recover_names((char_u *)fname, false, 0, NULL);
if (len == 0) { // no swap files found
semsg(_("E305: No swap file found for %s"), fname);
goto theend;
@ -794,7 +794,7 @@ void ml_recover(bool checkext)
i = 1;
} else { // several swap files found, choose
// list the names of the swap files
(void)recover_names(fname, true, 0, NULL);
(void)recover_names((char_u *)fname, true, 0, NULL);
msg_putchar('\n');
msg_puts(_("Enter number of swap file to use (0 to quit): "));
i = get_number(false, NULL);
@ -803,7 +803,7 @@ void ml_recover(bool checkext)
}
}
// get the swap file name that will be used
(void)recover_names(fname, false, i, &fname_used);
(void)recover_names((char_u *)fname, false, i, (char_u **)&fname_used);
}
if (fname_used == NULL) {
goto theend; // user chose invalid number.
@ -833,9 +833,9 @@ void ml_recover(bool checkext)
/*
* open the memfile from the old swap file
*/
p = vim_strsave(fname_used); // save "fname_used" for the message:
p = xstrdup(fname_used); // save "fname_used" for the message:
// mf_open() will consume "fname_used"!
mfp = mf_open((char *)fname_used, O_RDONLY);
mfp = mf_open(fname_used, O_RDONLY);
fname_used = p;
if (mfp == NULL || mfp->mf_fd < 0) {
semsg(_("E306: Cannot open %s"), fname_used);
@ -962,8 +962,8 @@ void ml_recover(bool checkext)
if (b0p->b0_flags & B0_HAS_FENC) {
int fnsize = B0_FNAME_SIZE_NOCRYPT;
for (p = b0p->b0_fname + fnsize; p > b0p->b0_fname && p[-1] != NUL; p--) {}
b0_fenc = vim_strnsave(p, (size_t)(b0p->b0_fname + fnsize - p));
for (p = (char *)b0p->b0_fname + fnsize; (char_u *)p > b0p->b0_fname && p[-1] != NUL; p--) {}
b0_fenc = xstrnsave(p, (size_t)(b0p->b0_fname + fnsize - (char_u *)p));
}
mf_put(mfp, hp, false, false); // release block 0
@ -991,7 +991,7 @@ void ml_recover(bool checkext)
set_fileformat(b0_ff - 1, OPT_LOCAL);
}
if (b0_fenc != NULL) {
set_option_value_give_err("fenc", 0L, (char *)b0_fenc, OPT_LOCAL);
set_option_value_give_err("fenc", 0L, b0_fenc, OPT_LOCAL);
xfree(b0_fenc);
}
unchanged(curbuf, true, true);
@ -1133,12 +1133,12 @@ void ml_recover(bool checkext)
txt_start = (dp->db_index[i] & DB_INDEX_MASK);
if (txt_start <= (int)HEADER_SIZE
|| txt_start >= (int)dp->db_txt_end) {
p = (char_u *)"???";
p = "???";
error++;
} else {
p = (char_u *)dp + txt_start;
p = (char *)dp + txt_start;
}
ml_append(lnum++, (char *)p, (colnr_T)0, true);
ml_append(lnum++, p, (colnr_T)0, true);
}
if (has_error) {
ml_append(lnum++, _("???END"), (colnr_T)0, true);
@ -1177,7 +1177,7 @@ void ml_recover(bool checkext)
} else {
for (idx = 1; idx <= lnum; idx++) {
// Need to copy one line, fetching the other one may flush it.
p = vim_strsave((char_u *)ml_get(idx));
p = xstrdup(ml_get(idx));
i = STRCMP(p, ml_get(idx + lnum));
xfree(p);
if (i != 0) {

6
src/nvim/message.c
View File

@ -1581,7 +1581,7 @@ int msg_outtrans_len_attr(const char *msgstr, int len, int attr)
*/
while (--len >= 0 && !got_int) {
// Don't include composing chars after the end.
mb_l = utfc_ptr2len_len((char_u *)str, len + 1);
mb_l = utfc_ptr2len_len(str, len + 1);
if (mb_l > 1) {
c = utf_ptr2char(str);
if (vim_isprintc(c)) {
@ -2219,7 +2219,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse)
if (has_last_char) {
if (maxlen >= 0) {
// Avoid including composing chars after the end.
l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
} else {
l = utfc_ptr2len(s);
}
@ -2316,7 +2316,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse)
cw = utf_ptr2cells(s);
if (maxlen >= 0) {
// avoid including composing chars after the end
l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
} else {
l = utfc_ptr2len(s);
}

24
src/nvim/normal.c
View File

@ -3134,7 +3134,7 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
} else {
par_pos = curwin->w_cursor;
while (curwin->w_cursor.lnum > 1
&& *skipwhite((char *)get_cursor_line_ptr()) != NUL) {
&& *skipwhite(get_cursor_line_ptr()) != NUL) {
curwin->w_cursor.lnum--;
}
}
@ -3171,13 +3171,13 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
}
break;
}
if (get_leader_len((char *)get_cursor_line_ptr(), NULL, false, true) > 0) {
if (get_leader_len(get_cursor_line_ptr(), NULL, false, true) > 0) {
// Ignore this line, continue at start of next line.
curwin->w_cursor.lnum++;
curwin->w_cursor.col = 0;
continue;
}
bool valid = is_ident(get_cursor_line_ptr(), curwin->w_cursor.col);
bool valid = is_ident((char_u *)get_cursor_line_ptr(), curwin->w_cursor.col);
// If the current position is not a valid identifier and a previous match is
// present, favor that one instead.
@ -3232,7 +3232,7 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
/// @return true if able to move cursor, false otherwise.
static bool nv_screengo(oparg_T *oap, int dir, long dist)
{
int linelen = linetabsize(get_cursor_line_ptr());
int linelen = linetabsize((char_u *)get_cursor_line_ptr());
bool retval = true;
bool atend = false;
int n;
@ -3303,7 +3303,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
}
curwin->w_cursor.lnum--;
linelen = linetabsize(get_cursor_line_ptr());
linelen = linetabsize((char_u *)get_cursor_line_ptr());
if (linelen > width1) {
int w = (((linelen - width1 - 1) / width2) + 1) * width2;
assert(curwin->w_curswant <= INT_MAX - w);
@ -3339,7 +3339,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
if (curwin->w_curswant >= width1) {
curwin->w_curswant -= width2;
}
linelen = linetabsize(get_cursor_line_ptr());
linelen = linetabsize((char_u *)get_cursor_line_ptr());
}
}
}
@ -4294,7 +4294,7 @@ static void nv_ident(cmdarg_T *cap)
// Call setpcmark() first, so "*``" puts the cursor back where
// it was.
setpcmark();
curwin->w_cursor.col = (colnr_T)(ptr - (char *)get_cursor_line_ptr());
curwin->w_cursor.col = (colnr_T)(ptr - get_cursor_line_ptr());
if (!g_cmd && vim_iswordp((char_u *)ptr)) {
STRCPY(buf, "\\<");
@ -4382,13 +4382,13 @@ static void nv_ident(cmdarg_T *cap)
// Execute the command.
if (cmdchar == '*' || cmdchar == '#') {
if (!g_cmd
&& vim_iswordp(mb_prevptr(get_cursor_line_ptr(), (char_u *)ptr))) {
&& vim_iswordp(mb_prevptr((char_u *)get_cursor_line_ptr(), (char_u *)ptr))) {
STRCAT(buf, "\\>");
}
// put pattern in search history
init_history();
add_to_history(HIST_SEARCH, (char_u *)buf, true, NUL);
add_to_history(HIST_SEARCH, buf, true, NUL);
(void)normal_search(cap, cmdchar == '*' ? '/' : '?', buf, 0, NULL);
} else {
@ -4425,7 +4425,7 @@ bool get_visual_text(cmdarg_T *cap, char **pp, size_t *lenp)
return false;
}
if (VIsual_mode == 'V') {
*pp = (char *)get_cursor_line_ptr();
*pp = get_cursor_line_ptr();
*lenp = STRLEN(*pp);
} else {
if (lt(curwin->w_cursor, VIsual)) {
@ -6068,7 +6068,7 @@ static void nv_g_underscore_cmd(cmdarg_T *cap)
return;
}
char_u *ptr = get_cursor_line_ptr();
char_u *ptr = (char_u *)get_cursor_line_ptr();
// In Visual mode we may end up after the line.
if (curwin->w_cursor.col > 0 && ptr[curwin->w_cursor.col] == NUL) {
@ -6279,7 +6279,7 @@ static void nv_g_cmd(cmdarg_T *cap)
case 'M':
oap->motion_type = kMTCharWise;
oap->inclusive = false;
i = linetabsize(get_cursor_line_ptr());
i = linetabsize((char_u *)get_cursor_line_ptr());
if (cap->count0 > 0 && cap->count0 <= 100) {
coladvance((colnr_T)(i * cap->count0 / 100));
} else {

82
src/nvim/ops.c
View File

@ -225,7 +225,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
}
for (i = oap->line_count - 1; i >= 0; i--) {
first_char = *get_cursor_line_ptr();
first_char = (uint8_t)(*get_cursor_line_ptr());
if (first_char == NUL) { // empty line
curwin->w_cursor.col = 0;
} else if (oap->motion_type == kMTBlockWise) {
@ -356,7 +356,7 @@ static void shift_block(oparg_T *oap, int amount)
return; // multiplication overflow
}
char_u *const oldp = get_cursor_line_ptr();
char_u *const oldp = (char_u *)get_cursor_line_ptr();
int startcol, oldlen, newlen;
@ -668,7 +668,7 @@ void op_reindent(oparg_T *oap, Indenter how)
// indented, unless there is only one line.
if (i != oap->line_count - 1 || oap->line_count == 1
|| how != get_lisp_indent) {
l = (char_u *)skipwhite((char *)get_cursor_line_ptr());
l = (char_u *)skipwhite(get_cursor_line_ptr());
if (*l == NUL) { // empty or blank line
amount = 0;
} else {
@ -1735,7 +1735,7 @@ int op_delete(oparg_T *oap)
if (virtual_op) {
// fix up things for virtualedit-delete:
// break the tabs which are going to get in our way
char_u *curline = get_cursor_line_ptr();
char_u *curline = (char_u *)get_cursor_line_ptr();
int len = (int)STRLEN(curline);
if (oap->end.coladd != 0
@ -1926,7 +1926,7 @@ static int op_replace(oparg_T *oap, int c)
num_chars = numc;
numc *= utf_char2len(c);
oldp = get_cursor_line_ptr();
oldp = (char_u *)get_cursor_line_ptr();
oldlen = (int)STRLEN(oldp);
size_t newp_size = (size_t)bd.textcol + (size_t)bd.startspaces;
@ -2240,7 +2240,7 @@ bool swapchar(int op_type, pos_T *pos)
void op_insert(oparg_T *oap, long count1)
{
long ins_len, pre_textlen = 0;
char_u *firstline, *ins_text;
char *firstline, *ins_text;
colnr_T ind_pre_col = 0, ind_post_col;
int ind_pre_vcol = 0, ind_post_vcol = 0;
struct block_def bd;
@ -2281,7 +2281,7 @@ void op_insert(oparg_T *oap, long count1)
// Get indent information
ind_pre_col = (colnr_T)getwhitecols_curline();
ind_pre_vcol = get_indent();
firstline = (char_u *)ml_get(oap->start.lnum) + bd.textcol;
firstline = ml_get(oap->start.lnum) + bd.textcol;
if (oap->op_type == OP_APPEND) {
firstline += bd.textlen;
@ -2413,7 +2413,7 @@ void op_insert(oparg_T *oap, long count1)
* Subsequent calls to ml_get() flush the firstline data - take a
* copy of the required string.
*/
firstline = (char_u *)ml_get(oap->start.lnum);
firstline = ml_get(oap->start.lnum);
const size_t len = STRLEN(firstline);
colnr_T add = bd.textcol;
colnr_T offset = 0; // offset when cursor was moved in insert mode
@ -2438,10 +2438,10 @@ void op_insert(oparg_T *oap, long count1)
}
ins_len = (long)STRLEN(firstline) - pre_textlen - offset;
if (pre_textlen >= 0 && ins_len > 0) {
ins_text = vim_strnsave(firstline, (size_t)ins_len);
ins_text = xstrnsave(firstline, (size_t)ins_len);
// block handled here
if (u_save(oap->start.lnum, (linenr_T)(oap->end.lnum + 1)) == OK) {
block_insert(oap, ins_text, (oap->op_type == OP_INSERT), &bd);
block_insert(oap, (char_u *)ins_text, (oap->op_type == OP_INSERT), &bd);
}
curwin->w_cursor.col = oap->start.col;
@ -2934,9 +2934,9 @@ static void do_autocmd_textyankpost(oparg_T *oap, yankreg_T *reg)
/// @param dir BACKWARD for 'P', FORWARD for 'p'
void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
{
char_u *ptr;
char_u *newp;
char_u *oldp;
char *ptr;
char *newp;
char *oldp;
int yanklen;
size_t totlen = 0; // init for gcc
linenr_T lnum = 0;
@ -3082,13 +3082,13 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
* Loop twice: count the number of lines and save them. */
for (;;) {
y_size = 0;
ptr = (char_u *)insert_string;
ptr = insert_string;
while (ptr != NULL) {
if (y_array != NULL) {
y_array[y_size] = (char *)ptr;
y_array[y_size] = ptr;
}
y_size++;
ptr = (char_u *)vim_strchr((char *)ptr, '\n');
ptr = vim_strchr(ptr, '\n');
if (ptr != NULL) {
if (y_array != NULL) {
*ptr = NUL;
@ -3136,12 +3136,12 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
if (u_save_cursor() == FAIL) {
goto end;
}
char_u *p = get_cursor_pos_ptr();
char *p = (char *)get_cursor_pos_ptr();
if (dir == FORWARD && *p != NUL) {
MB_PTR_ADV(p);
}
ptr = vim_strsave(p);
ml_append(curwin->w_cursor.lnum, (char *)ptr, (colnr_T)0, false);
ptr = xstrdup(p);
ml_append(curwin->w_cursor.lnum, ptr, (colnr_T)0, false);
xfree(ptr);
oldp = get_cursor_line_ptr();
@ -3149,8 +3149,8 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
if (dir == FORWARD && *p != NUL) {
MB_PTR_ADV(p);
}
ptr = vim_strnsave(oldp, (size_t)(p - oldp));
ml_replace(curwin->w_cursor.lnum, (char *)ptr, false);
ptr = xstrnsave(oldp, (size_t)(p - oldp));
ml_replace(curwin->w_cursor.lnum, ptr, false);
nr_lines++;
dir = FORWARD;
}
@ -3298,8 +3298,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
oldp = get_cursor_line_ptr();
oldlen = STRLEN(oldp);
chartabsize_T cts;
init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum, 0,
(char *)oldp, (char *)oldp);
init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum, 0, oldp, oldp);
while (cts.cts_vcol < col && *cts.cts_ptr != NUL) {
// Count a tab for what it's worth (if list mode not on)
@ -3307,7 +3306,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
cts.cts_vcol += incr;
}
vcol = cts.cts_vcol;
ptr = (char_u *)cts.cts_ptr;
ptr = cts.cts_ptr;
bd.textcol = (colnr_T)(ptr - oldp);
clear_chartabsize_arg(&cts);
@ -3320,7 +3319,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
bd.startspaces = incr - bd.endspaces;
bd.textcol--;
delcount = 1;
bd.textcol -= utf_head_off((char *)oldp, (char *)oldp + bd.textcol);
bd.textcol -= utf_head_off(oldp, oldp + bd.textcol);
if (oldp[bd.textcol] != TAB) {
/* Only a Tab can be split into spaces. Other
* characters will have to be moved to after the
@ -3356,9 +3355,8 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
break;
}
totlen = (size_t)(count * (yanklen + spaces)
+ bd.startspaces + bd.endspaces);
newp = (char_u *)xmalloc(totlen + oldlen + 1);
totlen = (size_t)(count * (yanklen + spaces) + bd.startspaces + bd.endspaces);
newp = xmalloc(totlen + oldlen + 1);
// copy part up to cursor to new line
ptr = newp;
@ -3391,7 +3389,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
int columns = (int)oldlen - bd.textcol - delcount + 1;
assert(columns >= 0);
memmove(ptr, oldp + bd.textcol + delcount, (size_t)columns);
ml_replace(curwin->w_cursor.lnum, (char *)newp, false);
ml_replace(curwin->w_cursor.lnum, newp, false);
extmark_splice_cols(curbuf, (int)curwin->w_cursor.lnum - 1, bd.textcol,
delcount, (int)totlen + lines_appended, kExtmarkUndo);
@ -3482,7 +3480,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
} else {
totlen = (size_t)(count * yanklen);
do {
oldp = (char_u *)ml_get(lnum);
oldp = ml_get(lnum);
oldlen = STRLEN(oldp);
if (lnum > start_lnum) {
pos_T pos = {
@ -3498,7 +3496,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
lnum++;
continue;
}
newp = (char_u *)xmalloc(totlen + oldlen + 1);
newp = xmalloc(totlen + oldlen + 1);
memmove(newp, oldp, (size_t)col);
ptr = newp + col;
for (i = 0; i < (size_t)count; i++) {
@ -3506,10 +3504,10 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
ptr += yanklen;
}
STRMOVE(ptr, oldp + col);
ml_replace(lnum, (char *)newp, false);
ml_replace(lnum, newp, false);
// compute the byte offset for the last character
first_byte_off = utf_head_off((char *)newp, (char *)ptr - 1);
first_byte_off = utf_head_off(newp, ptr - 1);
// Place cursor on last putted char.
if (lnum == curwin->w_cursor.lnum) {
@ -3553,23 +3551,23 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
// First insert y_array[size - 1] in front of second line.
// Then append y_array[0] to first line.
lnum = new_cursor.lnum;
ptr = (char_u *)ml_get(lnum) + col;
ptr = ml_get(lnum) + col;
totlen = STRLEN(y_array[y_size - 1]);
newp = (char_u *)xmalloc((size_t)(STRLEN(ptr) + totlen + 1));
newp = xmalloc((size_t)(STRLEN(ptr) + totlen + 1));
STRCPY(newp, y_array[y_size - 1]);
STRCAT(newp, ptr);
// insert second line
ml_append(lnum, (char *)newp, (colnr_T)0, false);
ml_append(lnum, newp, (colnr_T)0, false);
new_lnum++;
xfree(newp);
oldp = (char_u *)ml_get(lnum);
newp = (char_u *)xmalloc((size_t)col + (size_t)yanklen + 1);
oldp = ml_get(lnum);
newp = xmalloc((size_t)col + (size_t)yanklen + 1);
// copy first part of line
memmove(newp, oldp, (size_t)col);
// append to first line
memmove(newp + col, y_array[0], (size_t)yanklen + 1);
ml_replace(lnum, (char *)newp, false);
ml_replace(lnum, newp, false);
curwin->w_cursor.lnum = lnum;
i = 1;
@ -3587,7 +3585,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
if (flags & PUT_FIXINDENT) {
old_pos = curwin->w_cursor;
curwin->w_cursor.lnum = lnum;
ptr = (char_u *)ml_get(lnum);
ptr = ml_get(lnum);
if (cnt == count && i == y_size - 1) {
lendiff = (int)STRLEN(ptr);
}
@ -4656,7 +4654,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
: length);
}
vim_str2nr(ptr + col, &pre, &length,
vim_str2nr((char *)ptr + col, &pre, &length,
0 + (do_bin ? STR2NR_BIN : 0)
+ (do_oct ? STR2NR_OCT : 0)
+ (do_hex ? STR2NR_HEX : 0),
@ -5504,7 +5502,7 @@ void cursor_pos_info(dict_T *dict)
(int64_t)byte_count_cursor, (int64_t)byte_count);
}
} else {
p = get_cursor_line_ptr();
p = (char_u *)get_cursor_line_ptr();
validate_virtcol();
col_print((char *)buf1, sizeof(buf1), (int)curwin->w_cursor.col + 1,
(int)curwin->w_virtcol + 1);

6
src/nvim/option.c
View File

@ -664,8 +664,8 @@ void set_init_3(void)
: !(options[idx_sp].flags & P_WAS_SET);
size_t len = 0;
char_u *p = (char_u *)invocation_path_tail(p_sh, &len);
p = vim_strnsave(p, len);
char *p = (char *)invocation_path_tail(p_sh, &len);
p = xstrnsave(p, len);
{
//
@ -1131,7 +1131,7 @@ int do_set(char *arg, int opt_flags)
}
} else if (*arg == '-' || ascii_isdigit(*arg)) {
// Allow negative, octal and hex numbers.
vim_str2nr((char_u *)arg, NULL, &i, STR2NR_ALL, &value, NULL, 0, true);
vim_str2nr(arg, NULL, &i, STR2NR_ALL, &value, NULL, 0, true);
if (i == 0 || (arg[i] != NUL && !ascii_iswhite(arg[i]))) {
errmsg = e_number_required_after_equal;
goto skip;

4
src/nvim/os/shell.c
View File

@ -64,7 +64,7 @@ static void save_patterns(int num_pat, char **pat, int *num_file, char ***file)
static bool have_wildcard(int num, char **file)
{
for (int i = 0; i < num; i++) {
if (path_has_wildcard((char_u *)file[i])) {
if (path_has_wildcard(file[i])) {
return true;
}
}
@ -1106,7 +1106,7 @@ static void out_data_append_to_screen(char *output, size_t *count, bool eof)
// incomplete UTF-8 sequence that could be composing with the last
// complete sequence.
// This will be corrected when we switch to vterm based implementation
int i = *p ? utfc_ptr2len_len((char_u *)p, (int)(end - p)) : 1;
int i = *p ? utfc_ptr2len_len(p, (int)(end - p)) : 1;
if (!eof && i == 1 && utf8len_tab_zero[*(uint8_t *)p] > (end - p)) {
*count = (size_t)(p - output);
goto end;

33
src/nvim/path.c
View File

@ -509,7 +509,7 @@ char *save_abs_path(const char *name)
/// @param p The path to expand.
/// @returns Unix: True if it contains one of "?[{`'$".
/// @returns Windows: True if it contains one of "*?$[".
bool path_has_wildcard(const char_u *p)
bool path_has_wildcard(const char *p)
FUNC_ATTR_NONNULL_ALL
{
for (; *p; MB_PTR_ADV(p)) {
@ -1252,7 +1252,7 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
p = (char_u *)pat[i];
if (vim_backtick(p)) {
add_pat = expand_backtick(&ga, p, flags);
add_pat = expand_backtick(&ga, (char *)p, flags);
if (add_pat == -1) {
recursive = false;
FreeWild(ga.ga_len, ga.ga_data);
@ -1367,14 +1367,14 @@ static int vim_backtick(char_u *p)
/// Returns number of file names found, -1 if an error is encountered.
///
/// @param flags EW_* flags
static int expand_backtick(garray_T *gap, char_u *pat, int flags)
static int expand_backtick(garray_T *gap, char *pat, int flags)
{
char *p;
char *buffer;
int cnt = 0;
// Create the command: lop off the backticks.
char *cmd = (char *)vim_strnsave(pat + 1, STRLEN(pat) - 2);
char *cmd = xstrnsave(pat + 1, STRLEN(pat) - 2);
if (*cmd == '=') { // `={expr}`: Expand expression
buffer = eval_to_string(cmd + 1, &p, true);
@ -1683,17 +1683,17 @@ static char *eval_includeexpr(const char *const ptr, const size_t len)
/// Otherwise like file_name_at_cursor().
///
/// @param rel_fname file we are searching relative to
char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count, char_u *rel_fname)
char *find_file_name_in_path(char *ptr, size_t len, int options, long count, char *rel_fname)
{
char_u *file_name;
char_u *tofree = NULL;
char *file_name;
char *tofree = NULL;
if (len == 0) {
return NULL;
}
if ((options & FNAME_INCL) && *curbuf->b_p_inex != NUL) {
tofree = (char_u *)eval_includeexpr((char *)ptr, len);
tofree = eval_includeexpr(ptr, len);
if (tofree != NULL) {
ptr = tofree;
len = STRLEN(ptr);
@ -1701,8 +1701,8 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
}
if (options & FNAME_EXP) {
file_name = find_file_in_path(ptr, len, options & ~FNAME_MESS, true,
rel_fname);
file_name = (char *)find_file_in_path((char_u *)ptr, len, options & ~FNAME_MESS, true,
(char_u *)rel_fname);
/*
* If the file could not be found in a normal way, try applying
@ -1710,16 +1710,16 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
*/
if (file_name == NULL
&& !(options & FNAME_INCL) && *curbuf->b_p_inex != NUL) {
tofree = (char_u *)eval_includeexpr((char *)ptr, len);
tofree = eval_includeexpr(ptr, len);
if (tofree != NULL) {
ptr = tofree;
len = STRLEN(ptr);
file_name = find_file_in_path(ptr, len, options & ~FNAME_MESS,
true, rel_fname);
file_name = (char *)find_file_in_path((char_u *)ptr, len, options & ~FNAME_MESS,
true, (char_u *)rel_fname);
}
}
if (file_name == NULL && (options & FNAME_MESS)) {
char_u c = ptr[len];
char c = ptr[len];
ptr[len] = NUL;
semsg(_("E447: Can't find file \"%s\" in path"), ptr);
ptr[len] = c;
@ -1729,10 +1729,11 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
* appears several times in the path. */
while (file_name != NULL && --count > 0) {
xfree(file_name);
file_name = find_file_in_path(ptr, len, options, false, rel_fname);
file_name =
(char *)find_file_in_path((char_u *)ptr, len, options, false, (char_u *)rel_fname);
}
} else {
file_name = vim_strnsave(ptr, len);
file_name = xstrnsave(ptr, len);
}
xfree(tofree);

6
src/nvim/regexp.c
View File

@ -1623,14 +1623,14 @@ static int fill_submatch_list(int argc FUNC_ATTR_UNUSED, typval_T *argv, int arg
// There are always 10 list items in staticList10_T.
listitem_T *li = tv_list_first(listarg->vval.v_list);
for (int i = 0; i < 10; i++) {
char_u *s = rsm.sm_match->startp[i];
char *s = (char *)rsm.sm_match->startp[i];
if (s == NULL || rsm.sm_match->endp[i] == NULL) {
s = NULL;
} else {
s = vim_strnsave(s, (size_t)(rsm.sm_match->endp[i] - s));
s = xstrnsave(s, (size_t)(rsm.sm_match->endp[i] - (char_u *)s));
}
TV_LIST_ITEM_TV(li)->v_type = VAR_STRING;
TV_LIST_ITEM_TV(li)->vval.v_string = (char *)s;
TV_LIST_ITEM_TV(li)->vval.v_string = s;
li = TV_LIST_ITEM_NEXT(argv->vval.v_list, li);
}
return argskip + 1;

14
src/nvim/regexp_bt.c
View File

@ -2469,7 +2469,7 @@ do_multibyte:
// Need to get composing character too.
for (;;) {
l = utf_ptr2len((char *)regparse);
if (!utf_composinglike((char_u *)regparse, (char_u *)regparse + l)) {
if (!utf_composinglike(regparse, regparse + l)) {
break;
}
regmbc(utf_ptr2char((char *)regparse));
@ -3192,7 +3192,7 @@ static int regrepeat(char_u *p, long maxcount)
case SKWORD:
case SKWORD + ADD_NL:
while (count < maxcount) {
if (vim_iswordp_buf(scan, rex.reg_buf)
if (vim_iswordp_buf((char *)scan, rex.reg_buf)
&& (testval || !ascii_isdigit(*scan))) {
MB_PTR_ADV(scan);
} else if (*scan == NUL) {
@ -3829,7 +3829,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
break;
case KWORD:
if (!vim_iswordp_buf(rex.input, rex.reg_buf)) {
if (!vim_iswordp_buf((char *)rex.input, rex.reg_buf)) {
status = RA_NOMATCH;
} else {
ADVANCE_REGINPUT();
@ -3838,7 +3838,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
case SKWORD:
if (ascii_isdigit(*rex.input)
|| !vim_iswordp_buf(rex.input, rex.reg_buf)) {
|| !vim_iswordp_buf((char *)rex.input, rex.reg_buf)) {
status = RA_NOMATCH;
} else {
ADVANCE_REGINPUT();
@ -4046,7 +4046,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
// Check for following composing character, unless %C
// follows (skips over all composing chars).
if (status != RA_NOMATCH
&& utf_composinglike(rex.input, rex.input + len)
&& utf_composinglike((char *)rex.input, (char *)rex.input + len)
&& !rex.reg_icombine
&& OP(next) != RE_COMPOSING) {
// raaron: This code makes a composing character get
@ -4975,13 +4975,13 @@ static long regtry(bt_regprog_T *prog, colnr_T col, proftime_T *tm, int *timed_o
&& reg_endzpos[i].lnum == reg_startzpos[i].lnum
&& reg_endzpos[i].col >= reg_startzpos[i].col) {
re_extmatch_out->matches[i] =
vim_strnsave(reg_getline(reg_startzpos[i].lnum) + reg_startzpos[i].col,
(char_u *)xstrnsave((char *)reg_getline(reg_startzpos[i].lnum) + reg_startzpos[i].col,
(size_t)(reg_endzpos[i].col - reg_startzpos[i].col));
}
} else {
if (reg_startzp[i] != NULL && reg_endzp[i] != NULL) {
re_extmatch_out->matches[i] =
vim_strnsave(reg_startzp[i], (size_t)(reg_endzp[i] - reg_startzp[i]));
(char_u *)xstrnsave((char *)reg_startzp[i], (size_t)(reg_endzp[i] - reg_startzp[i]));
}
}
}

8
src/nvim/regexp_nfa.c
View File

@ -6643,13 +6643,13 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start, regsubs_T *subm
break;
case NFA_KWORD: // \k
result = vim_iswordp_buf(rex.input, rex.reg_buf);
result = vim_iswordp_buf((char *)rex.input, rex.reg_buf);
ADD_STATE_IF_MATCH(t->state);
break;
case NFA_SKWORD: // \K
result = !ascii_isdigit(curc)
&& vim_iswordp_buf(rex.input, rex.reg_buf);
&& vim_iswordp_buf((char *)rex.input, rex.reg_buf);
ADD_STATE_IF_MATCH(t->state);
break;
@ -7362,7 +7362,7 @@ static long nfa_regtry(nfa_regprog_T *prog, colnr_T col, proftime_T *tm, int *ti
&& mpos->start_lnum == mpos->end_lnum
&& mpos->end_col >= mpos->start_col) {
re_extmatch_out->matches[i] =
vim_strnsave(reg_getline(mpos->start_lnum) + mpos->start_col,
(char_u *)xstrnsave((char *)reg_getline(mpos->start_lnum) + mpos->start_col,
(size_t)(mpos->end_col - mpos->start_col));
}
} else {
@ -7370,7 +7370,7 @@ static long nfa_regtry(nfa_regprog_T *prog, colnr_T col, proftime_T *tm, int *ti
if (lpos->start != NULL && lpos->end != NULL) {
re_extmatch_out->matches[i] =
vim_strnsave(lpos->start, (size_t)(lpos->end - lpos->start));
(char_u *)xstrnsave((char *)lpos->start, (size_t)(lpos->end - lpos->start));
}
}
}

25
src/nvim/search.c
View File

@ -161,7 +161,7 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc
magic = spats[i].magic;
no_smartcase = spats[i].no_scs;
} else if (options & SEARCH_HIS) { // put new pattern in history
add_to_history(HIST_SEARCH, pat, true, NUL);
add_to_history(HIST_SEARCH, (char *)pat, true, NUL);
}
if (mr_pattern_alloced) {
@ -1574,7 +1574,7 @@ int searchc(cmdarg_T *cap, int t_cmd)
cap->oap->inclusive = true;
}
p = get_cursor_line_ptr();
p = (char_u *)get_cursor_line_ptr();
col = curwin->w_cursor.col;
len = (int)STRLEN(p);
@ -1649,22 +1649,21 @@ static bool check_prevcol(char_u *linep, int col, int ch, int *prevcol)
return col >= 0 && linep[col] == ch;
}
/*
* Raw string start is found at linep[startpos.col - 1].
* Return true if the matching end can be found between startpos and endpos.
*/
static bool find_rawstring_end(char_u *linep, pos_T *startpos, pos_T *endpos)
/// Raw string start is found at linep[startpos.col - 1].
///
/// @return true if the matching end can be found between startpos and endpos.
static bool find_rawstring_end(char *linep, pos_T *startpos, pos_T *endpos)
{
char_u *p;
char *p;
linenr_T lnum;
for (p = linep + startpos->col + 1; *p && *p != '('; p++) {}
size_t delim_len = (size_t)((p - linep) - startpos->col - 1);
char_u *delim_copy = vim_strnsave(linep + startpos->col + 1, delim_len);
char *delim_copy = xstrnsave(linep + startpos->col + 1, delim_len);
bool found = false;
for (lnum = startpos->lnum; lnum <= endpos->lnum; lnum++) {
char_u *line = (char_u *)ml_get(lnum);
char *line = ml_get(lnum);
for (p = line + (lnum == startpos->lnum ? startpos->col + 1 : 0); *p; p++) {
if (lnum == endpos->lnum && (colnr_T)(p - line) >= endpos->col) {
@ -2082,7 +2081,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
// delimiter we can check if it ends before where we
// started searching, or before the previously found
// raw string start.
if (!find_rawstring_end(linep, &pos,
if (!find_rawstring_end((char *)linep, &pos,
count > 0 ? &match_pos : &curwin->w_cursor)) {
count++;
match_pos = pos;
@ -3598,11 +3597,11 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
if (inc_opt != NULL && strstr(inc_opt, "\\zs") != NULL) {
// Use text from '\zs' to '\ze' (or end) of 'include'.
new_fname = find_file_name_in_path(incl_regmatch.startp[0],
new_fname = (char_u *)find_file_name_in_path((char *)incl_regmatch.startp[0],
(size_t)(incl_regmatch.endp[0]
- incl_regmatch.startp[0]),
FNAME_EXP|FNAME_INCL|FNAME_REL,
1L, p_fname);
1L, (char *)p_fname);
} else {
// Use text after match with 'include'.
new_fname = file_name_in_line(incl_regmatch.endp[0], 0,

6
src/nvim/shada.c
View File

@ -882,9 +882,9 @@ static const void *shada_hist_iter(const void *const iter, const uint8_t history
.data = {
.history_item = {
.histtype = history_type,
.string = (char *)hist_he.hisstr,
.string = hist_he.hisstr,
.sep = (char)(history_type == HIST_SEARCH
? (char)hist_he.hisstr[STRLEN(hist_he.hisstr) + 1]
? hist_he.hisstr[STRLEN(hist_he.hisstr) + 1]
: 0),
.additional_elements = hist_he.additional_elements,
}
@ -1008,7 +1008,7 @@ static inline void hms_to_he_array(const HistoryMergerState *const hms_p,
HMLL_FORALL(&hms_p->hmll, cur_entry, {
hist->timestamp = cur_entry->data.timestamp;
hist->hisnum = (int)(hist - hist_array) + 1;
hist->hisstr = (char_u *)cur_entry->data.data.history_item.string;
hist->hisstr = cur_entry->data.data.history_item.string;
hist->additional_elements =
cur_entry->data.data.history_item.additional_elements;
hist++;

22
src/nvim/spell.c
View File

@ -2104,8 +2104,8 @@ static void clear_midword(win_T *wp)
XFREE_CLEAR(wp->w_s->b_spell_ismw_mb);
}
// Use the "sl_midword" field of language "lp" for buffer "buf".
// They add up to any currently used midword characters.
/// Use the "sl_midword" field of language "lp" for buffer "buf".
/// They add up to any currently used midword characters.
static void use_midword(slang_T *lp, win_T *wp)
FUNC_ATTR_NONNULL_ALL
{
@ -2113,20 +2113,20 @@ static void use_midword(slang_T *lp, win_T *wp)
return;
}
for (char_u *p = lp->sl_midword; *p != NUL;) {
const int c = utf_ptr2char((char *)p);
const int l = utfc_ptr2len((char *)p);
for (char *p = (char *)lp->sl_midword; *p != NUL;) {
const int c = utf_ptr2char(p);
const int l = utfc_ptr2len(p);
if (c < 256 && l <= 2) {
wp->w_s->b_spell_ismw[c] = true;
} else if (wp->w_s->b_spell_ismw_mb == NULL) {
// First multi-byte char in "b_spell_ismw_mb".
wp->w_s->b_spell_ismw_mb = (char *)vim_strnsave(p, (size_t)l);
wp->w_s->b_spell_ismw_mb = xstrnsave(p, (size_t)l);
} else {
// Append multi-byte chars to "b_spell_ismw_mb".
const int n = (int)STRLEN(wp->w_s->b_spell_ismw_mb);
char_u *bp = vim_strnsave((char_u *)wp->w_s->b_spell_ismw_mb, (size_t)n + (size_t)l);
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 = (char *)bp;
wp->w_s->b_spell_ismw_mb = bp;
STRLCPY(bp + n, p, l + 1);
}
p += l;
@ -2470,7 +2470,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
return false;
}
char_u *line = get_cursor_line_ptr();
char_u *line = (char_u *)get_cursor_line_ptr();
char_u *line_copy = NULL;
colnr_T endcol = 0;
if (getwhitecols((char *)line) >= (int)col) {
@ -2548,7 +2548,7 @@ void ex_spellrepall(exarg_T *eap)
// Only replace when the right word isn't there yet. This happens
// when changing "etc" to "etc.".
char_u *line = get_cursor_line_ptr();
char_u *line = (char_u *)get_cursor_line_ptr();
if (addlen <= 0 || STRNCMP(line + curwin->w_cursor.col,
repl_to, STRLEN(repl_to)) != 0) {
char_u *p = xmalloc(STRLEN(line) + (size_t)addlen + 1);
@ -3497,7 +3497,7 @@ int spell_word_start(int startcol)
return startcol;
}
char_u *line = get_cursor_line_ptr();
char_u *line = (char_u *)get_cursor_line_ptr();
char_u *p;
// Find a word character before "startcol".

47
src/nvim/spellsuggest.c
View File

@ -65,7 +65,7 @@ typedef struct suginfo_S {
/// One word suggestion. Used in "si_ga".
typedef struct {
char_u *st_word; ///< suggested word, allocated string
char *st_word; ///< suggested word, allocated string
int st_wordlen; ///< STRLEN(st_word)
int st_orglen; ///< length of replaced text
int st_score; ///< lower is better
@ -453,7 +453,7 @@ void spell_suggest(int count)
// No bad word or it starts after the cursor: use the word under the
// cursor.
curwin->w_cursor = prev_cursor;
line = get_cursor_line_ptr();
line = (char_u *)get_cursor_line_ptr();
p = line + curwin->w_cursor.col;
// Backup to before start of word.
while (p > line && spell_iswordp_nmw(p, curwin)) {
@ -477,7 +477,7 @@ void spell_suggest(int count)
need_cap = check_need_cap(curwin->w_cursor.lnum, curwin->w_cursor.col);
// Make a copy of current line since autocommands may free the line.
line = vim_strsave(get_cursor_line_ptr());
line = vim_strsave((char_u *)get_cursor_line_ptr());
spell_suggest_timeout = 5000;
// Get the list of suggestions. Limit to 'lines' - 2 or the number in
@ -593,15 +593,15 @@ void spell_suggest(int count)
if (sug.su_badlen > stp->st_orglen) {
// Replacing less than "su_badlen", append the remainder to
// repl_to.
repl_from = vim_strnsave(sug.su_badptr, (size_t)sug.su_badlen);
repl_from = (char_u *)xstrnsave((char *)sug.su_badptr, (size_t)sug.su_badlen);
vim_snprintf((char *)IObuff, IOSIZE, "%s%.*s", stp->st_word,
sug.su_badlen - stp->st_orglen,
sug.su_badptr + stp->st_orglen);
repl_to = vim_strsave(IObuff);
} else {
// Replacing su_badlen or more, use the whole word.
repl_from = vim_strnsave(sug.su_badptr, (size_t)stp->st_orglen);
repl_to = vim_strsave(stp->st_word);
repl_from = (char_u *)xstrnsave((char *)sug.su_badptr, (size_t)stp->st_orglen);
repl_to = vim_strsave((char_u *)stp->st_word);
}
// Replace the word.
@ -748,7 +748,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
c = utf_ptr2char((char *)su->su_badptr);
if (!SPELL_ISUPPER(c) && attr == HLF_COUNT) {
make_case_word(su->su_badword, buf, WF_ONECAP);
add_suggestion(su, &su->su_ga, buf, su->su_badlen, SCORE_ICASE,
add_suggestion(su, &su->su_ga, (char *)buf, su->su_badlen, SCORE_ICASE,
0, true, su->su_sallang, false);
}
@ -814,7 +814,7 @@ static void spell_suggest_expr(suginfo_T *su, char_u *expr)
// Get the word and the score from the items.
score = get_spellword(TV_LIST_ITEM_TV(li)->vval.v_list, &p);
if (score >= 0 && score <= su->su_maxscore) {
add_suggestion(su, &su->su_ga, (const char_u *)p, su->su_badlen,
add_suggestion(su, &su->su_ga, p, su->su_badlen,
score, 0, true, su->su_sallang, false);
}
}
@ -864,7 +864,7 @@ static void spell_suggest_file(suginfo_T *su, char_u *fname)
p = cword;
}
add_suggestion(su, &su->su_ga, p, su->su_badlen,
add_suggestion(su, &su->su_ga, (char *)p, su->su_badlen,
SCORE_FILE, 0, true, su->su_sallang, false);
}
}
@ -985,7 +985,7 @@ static void suggest_try_special(suginfo_T *su)
// Give a soundalike score of 0, compute the score as if deleting one
// character.
add_suggestion(su, &su->su_ga, word, su->su_badlen,
add_suggestion(su, &su->su_ga, (char *)word, su->su_badlen,
RESCORE(SCORE_REP, 0), 0, true, su->su_sallang, false);
}
}
@ -1330,7 +1330,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
sp->ts_prewordlen > 0);
// Add the suggestion if the score isn't too bad.
if (newscore <= su->su_maxscore) {
add_suggestion(su, &su->su_ga, preword,
add_suggestion(su, &su->su_ga, (char *)preword,
sp->ts_splitfidx - repextra,
newscore, 0, false,
lp->lp_sallang, false);
@ -1492,7 +1492,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
// Add the suggestion if the score isn't too bad.
if (score <= su->su_maxscore) {
add_suggestion(su, &su->su_ga, preword,
add_suggestion(su, &su->su_ga, (char *)preword,
sp->ts_fidx - repextra,
score, 0, false, lp->lp_sallang, false);
@ -1505,7 +1505,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
preword + sp->ts_prewordlen,
c == 0 ? WF_ALLCAP : 0);
add_suggestion(su, &su->su_ga, preword,
add_suggestion(su, &su->su_ga, (char *)preword,
sp->ts_fidx - repextra,
score + SCORE_ICASE, 0, false,
lp->lp_sallang, false);
@ -2494,7 +2494,7 @@ static void score_comp_sal(suginfo_T *su)
if (score < SCORE_MAXMAX) {
// Add the suggestion.
sstp = &SUG(su->su_sga, su->su_sga.ga_len);
sstp->st_word = vim_strsave(stp->st_word);
sstp->st_word = xstrdup(stp->st_word);
sstp->st_wordlen = stp->st_wordlen;
sstp->st_score = score;
sstp->st_altscore = 0;
@ -2551,8 +2551,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, stp->st_word);
stp->st_altscore = spell_edit_score(slang, 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 {
@ -2579,7 +2578,7 @@ static void score_combine(suginfo_T *su)
gap = round == 1 ? &su->su_ga : &su->su_sga;
if (i < gap->ga_len) {
// Don't add a word if it's already there.
p = SUG(*gap, i).st_word;
p = (char_u *)SUG(*gap, i).st_word;
int j;
for (j = 0; j < ga.ga_len; j++) {
if (STRCMP(stp[j].st_word, p) == 0) {
@ -2636,7 +2635,7 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
// removing the space. Don't do it when the good word also contains a
// space.
if (ascii_iswhite(su->su_badptr[su->su_badlen])
&& *skiptowhite((char *)stp->st_word) == NUL) {
&& *skiptowhite(stp->st_word) == NUL) {
for (p = fword; *(p = (char_u *)skiptowhite((char *)p)) != NUL;) {
STRMOVE(p, p + 1);
}
@ -2654,7 +2653,7 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
su->su_badptr + su->su_badlen - lendiff, lendiff + 1);
pgood = goodword;
} else {
pgood = stp->st_word;
pgood = (char_u *)stp->st_word;
}
// Sound-fold the word and compute the score for the difference.
@ -2883,7 +2882,7 @@ badword:
if (sps_flags & SPS_DOUBLE) {
// Add the suggestion if the score isn't too bad.
if (score <= su->su_maxscore) {
add_suggestion(su, &su->su_sga, p, su->su_badlen,
add_suggestion(su, &su->su_sga, (char *)p, su->su_badlen,
score, 0, false, slang, false);
}
} else {
@ -2931,7 +2930,7 @@ badword:
// Add the suggestion if the score isn't too bad.
goodscore = RESCORE(goodscore, score);
if (goodscore <= su->su_sfmaxscore) {
add_suggestion(su, &su->su_ga, p, su->su_badlen,
add_suggestion(su, &su->su_ga, (char *)p, su->su_badlen,
goodscore, score, true, slang, true);
}
}
@ -3061,7 +3060,7 @@ static bool similar_chars(slang_T *slang, int c1, int c2)
/// @param had_bonus value for st_had_bonus
/// @param slang language for sound folding
/// @param maxsf su_maxscore applies to soundfold score, su_sfmaxscore to the total score.
static void add_suggestion(suginfo_T *su, garray_T *gap, const char_u *goodword, int badlenarg,
static void add_suggestion(suginfo_T *su, garray_T *gap, const char *goodword, int badlenarg,
int score, int altscore, bool had_bonus, slang_T *slang, bool maxsf)
{
int goodlen; // len of goodword changed
@ -3071,7 +3070,7 @@ static void add_suggestion(suginfo_T *su, garray_T *gap, const char_u *goodword,
// Minimize "badlen" for consistency. Avoids that changing "the the" to
// "thee the" is added next to changing the first "the" the "thee".
const char_u *pgood = goodword + STRLEN(goodword);
const char *pgood = goodword + STRLEN(goodword);
char_u *pbad = su->su_badptr + badlenarg;
for (;;) {
goodlen = (int)(pgood - goodword);
@ -3144,7 +3143,7 @@ static void add_suggestion(suginfo_T *su, garray_T *gap, const char_u *goodword,
if (i < 0) {
// Add a suggestion.
stp = GA_APPEND_VIA_PTR(suggest_T, gap);
stp->st_word = vim_strnsave(goodword, (size_t)goodlen);
stp->st_word = xstrnsave(goodword, (size_t)goodlen);
stp->st_wordlen = goodlen;
stp->st_score = score;
stp->st_altscore = altscore;

21
src/nvim/strings.c
View File

@ -59,15 +59,6 @@ char_u *vim_strsave(const char_u *string)
/// Copy up to `len` bytes of `string` into newly allocated memory and
/// terminate with a NUL. The allocated memory always has size `len + 1`, even
/// when `string` is shorter.
char_u *vim_strnsave(const char_u *string, size_t len)
FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
{
// strncpy is intentional: some parts of Vim use `string` shorter than `len`
// and expect the remainder to be zeroed out.
return (char_u *)strncpy(xmallocz(len), (char *)string, len);
}
/// A clone of vim_strnsave() that uses char* instead of char_u*
char *xstrnsave(const char *string, size_t len)
FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
{
@ -318,15 +309,13 @@ char_u *vim_strsave_up(const char_u *string)
return p1;
}
/*
* Like vim_strnsave(), but make all characters uppercase.
* This uses ASCII lower-to-upper case translation, language independent.
*/
char_u *vim_strnsave_up(const char_u *string, size_t len)
/// Like xstrnsave(), but make all characters uppercase.
/// This uses ASCII lower-to-upper case translation, language independent.
char *vim_strnsave_up(const char *string, size_t len)
FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
{
char_u *p1 = vim_strnsave(string, len);
vim_strup(p1);
char *p1 = xstrnsave(string, len);
vim_strup((char_u *)p1);
return p1;
}

33
src/nvim/syntax.c
View File

@ -93,7 +93,7 @@ typedef struct syn_pattern {
int16_t *sp_cont_list; // cont. group IDs, if non-zero
int16_t *sp_next_list; // next group IDs, if non-zero
struct sp_syn sp_syn; // struct passed to in_id_list()
char_u *sp_pattern; // regexp to match, pattern
char *sp_pattern; // regexp to match, pattern
regprog_T *sp_prog; // regexp to match, program
syn_time_T sp_time;
} synpat_T;
@ -1709,9 +1709,10 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
if (do_keywords) {
line = (char_u *)syn_getcurline();
const char_u *cur_pos = line + current_col;
if (vim_iswordp_buf(cur_pos, syn_buf)
if (vim_iswordp_buf((char *)cur_pos, syn_buf)
&& (current_col == 0
|| !vim_iswordp_buf(cur_pos - 1 - utf_head_off((char *)line, (char *)cur_pos - 1),
|| !vim_iswordp_buf((char *)cur_pos - 1 -
utf_head_off((char *)line, (char *)cur_pos - 1),
syn_buf))) {
syn_id = check_keyword_id((char *)line, (int)current_col, &endcol, &flags,
&next_list, cur_si, &cchar);
@ -2942,7 +2943,7 @@ static int check_keyword_id(char *const line, const int startcol, int *const end
int kwlen = 0;
do {
kwlen += utfc_ptr2len(kwp + kwlen);
} while (vim_iswordp_buf((char_u *)kwp + kwlen, syn_buf));
} while (vim_iswordp_buf(kwp + kwlen, syn_buf));
if (kwlen > MAXKEYWLEN) {
return 0;
@ -3772,14 +3773,14 @@ static void put_pattern(const char *const s, const int c, const synpat_T *const
msg_putchar(c);
// output the pattern, in between a char that is not in the pattern
for (i = 0; vim_strchr((char *)spp->sp_pattern, sepchars[i]) != NULL;) {
for (i = 0; vim_strchr(spp->sp_pattern, sepchars[i]) != NULL;) {
if (sepchars[++i] == NUL) {
i = 0; // no good char found, just use the first one
break;
}
}
msg_putchar(sepchars[i]);
msg_outtrans((char *)spp->sp_pattern);
msg_outtrans(spp->sp_pattern);
msg_putchar(sepchars[i]);
// output any pattern options
@ -4048,7 +4049,7 @@ static char *get_group_name(char *arg, char **name_end)
/// Return NULL for any error;
static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
{
char_u *gname_start, *gname;
char *gname_start, *gname;
int syn_id;
int len = 0;
char *p;
@ -4157,16 +4158,16 @@ static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, i
emsg(_("E393: group[t]here not accepted here"));
return NULL;
}
gname_start = (char_u *)arg;
gname_start = arg;
arg = skiptowhite(arg);
if (gname_start == (char_u *)arg) {
if (gname_start == arg) {
return NULL;
}
gname = vim_strnsave(gname_start, (size_t)((char_u *)arg - gname_start));
gname = xstrnsave(gname_start, (size_t)(arg - gname_start));
if (STRCMP(gname, "NONE") == 0) {
*opt->sync_idx = NONE_IDX;
} else {
syn_id = syn_name2id((char *)gname);
syn_id = syn_name2id(gname);
int i;
for (i = curwin->w_s->b_syn_patterns.ga_len; --i >= 0;) {
if (SYN_ITEMS(curwin->w_s)[i].sp_syn.id == syn_id
@ -4566,7 +4567,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
key_end++;
}
xfree(key);
key = (char *)vim_strnsave_up((char_u *)rest, (size_t)(key_end - rest));
key = vim_strnsave_up(rest, (size_t)(key_end - rest));
if (STRCMP(key, "MATCHGROUP") == 0) {
item = ITEM_MATCHGROUP;
} else if (STRCMP(key, "START") == 0) {
@ -5043,12 +5044,12 @@ static char *get_syn_pattern(char *arg, synpat_T *ci)
return NULL;
}
// store the pattern and compiled regexp program
ci->sp_pattern = vim_strnsave((char_u *)arg + 1, (size_t)(end - arg) - 1);
ci->sp_pattern = xstrnsave(arg + 1, (size_t)(end - arg) - 1);
// Make 'cpoptions' empty, to avoid the 'l' flag
cpo_save = p_cpo;
p_cpo = empty_option;
ci->sp_prog = vim_regcomp((char *)ci->sp_pattern, RE_MAGIC);
ci->sp_prog = vim_regcomp(ci->sp_pattern, RE_MAGIC);
p_cpo = cpo_save;
if (ci->sp_prog == NULL) {
@ -5137,7 +5138,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
arg_end = skiptowhite(arg_start);
next_arg = skipwhite(arg_end);
xfree(key);
key = (char *)vim_strnsave_up((char_u *)arg_start, (size_t)(arg_end - arg_start));
key = vim_strnsave_up(arg_start, (size_t)(arg_end - arg_start));
if (STRCMP(key, "CCOMMENT") == 0) {
if (!eap->skip) {
curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT;
@ -5975,7 +5976,7 @@ static void syntime_report(void)
proftime_T tm = profile_divide(spp->sp_time.total, (int)spp->sp_time.count);
p->average = tm;
p->id = spp->sp_syn.id;
p->pattern = spp->sp_pattern;
p->pattern = (char_u *)spp->sp_pattern;
}
}

25
src/nvim/tag.c
View File

@ -68,7 +68,7 @@ typedef struct tag_pointers {
// when 'tr' is set.
char_u *tagkind; // "kind:" value
char_u *tagkind_end; // end of tagkind
char_u *user_data; // user_data string
char *user_data; // user_data string
char_u *user_data_end; // end of user_data
linenr_T tagline; // "line:" value
} tagptrs_T;
@ -588,9 +588,8 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
if (use_tfu && parse_match(matches[cur_match], &tagp2) == OK
&& tagp2.user_data) {
XFREE_CLEAR(tagstack[tagstackidx].user_data);
tagstack[tagstackidx].user_data = (char *)vim_strnsave(tagp2.user_data,
(size_t)(tagp2.user_data_end -
tagp2.user_data));
tagstack[tagstackidx].user_data =
xstrnsave(tagp2.user_data, (size_t)(tagp2.user_data_end - (char_u *)tagp2.user_data));
}
tagstackidx++;
@ -1425,7 +1424,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
int help_pri = 0;
char_u *help_lang_find = NULL; // lang to be found
char_u help_lang[3]; // lang of current tags file
char_u *saved_pat = NULL; // copy of pat[]
char *saved_pat = NULL; // copy of pat[]
bool is_txt = false;
pat_T orgpat; // holds unconverted pattern info
@ -1503,9 +1502,9 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
if (orgpat.len > 3 && pat[orgpat.len - 3] == '@'
&& ASCII_ISALPHA(pat[orgpat.len - 2])
&& ASCII_ISALPHA(pat[orgpat.len - 1])) {
saved_pat = vim_strnsave((char_u *)pat, (size_t)orgpat.len - 3);
saved_pat = xstrnsave(pat, (size_t)orgpat.len - 3);
help_lang_find = (char_u *)&pat[orgpat.len - 2];
orgpat.pat = saved_pat;
orgpat.pat = (char_u *)saved_pat;
orgpat.len -= 3;
}
}
@ -2430,11 +2429,11 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
STRMOVE(filename + 1, filename);
*filename++ = NUL;
tnp->tn_search_ctx = vim_findfile_init((char_u *)buf, filename,
(char_u *)r_ptr, 100,
tnp->tn_search_ctx = vim_findfile_init(buf, (char *)filename,
r_ptr, 100,
false, // don't free visited list
FINDFILE_FILE, // we search for a file
tnp->tn_search_ctx, true, (char_u *)curbuf->b_ffname);
tnp->tn_search_ctx, true, curbuf->b_ffname);
if (tnp->tn_search_ctx != NULL) {
tnp->tn_did_filefind_init = true;
}
@ -2584,7 +2583,7 @@ static int parse_match(char *lbuf, tagptrs_T *tagp)
if (STRNCMP(p, "kind:", 5) == 0) {
tagp->tagkind = (char_u *)p + 5;
} else if (STRNCMP(p, "user_data:", 10) == 0) {
tagp->user_data = (char_u *)p + 10;
tagp->user_data = p + 10;
} else if (STRNCMP(p, "line:", 5) == 0) {
tagp->tagline = atoi(p + 5);
}
@ -2612,7 +2611,7 @@ static int parse_match(char *lbuf, tagptrs_T *tagp)
tagp->tagkind_end = (char_u *)p;
}
if (tagp->user_data != NULL) {
for (p = (char *)tagp->user_data;
for (p = tagp->user_data;
*p && *p != '\t' && *p != '\r' && *p != '\n';
MB_PTR_ADV(p)) {}
tagp->user_data_end = (char_u *)p;
@ -2980,7 +2979,7 @@ static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bo
/*
* Expand file name (for environment variables) when needed.
*/
if (expand && path_has_wildcard(fname)) {
if (expand && path_has_wildcard((char *)fname)) {
ExpandInit(&xpc);
xpc.xp_context = EXPAND_FILES;
expanded_fname = ExpandOne(&xpc, fname, NULL,

14
src/nvim/textformat.c
View File

@ -117,7 +117,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
// Don't break until after the comment leader
if (do_comments) {
char_u *line = get_cursor_line_ptr();
char_u *line = (char_u *)get_cursor_line_ptr();
leader_len = get_leader_len((char *)line, NULL, false, true);
if (leader_len == 0 && curbuf->b_p_cin) {
// Check for a line comment after code.
@ -624,8 +624,8 @@ void auto_format(bool trailblank, bool prev_line)
{
pos_T pos;
colnr_T len;
char_u *old;
char_u *new, *pnew;
char *old;
char *new, *pnew;
int wasatend;
int cc;
@ -663,7 +663,7 @@ void auto_format(bool trailblank, bool prev_line)
// With the 'c' flag in 'formatoptions' and 't' missing: only format
// comments.
if (has_format_option(FO_WRAP_COMS) && !has_format_option(FO_WRAP)
&& get_leader_len((char *)old, NULL, false, true) == 0) {
&& get_leader_len(old, NULL, false, true) == 0) {
return;
}
@ -700,10 +700,10 @@ void auto_format(bool trailblank, bool prev_line)
new = get_cursor_line_ptr();
len = (colnr_T)STRLEN(new);
if (curwin->w_cursor.col == len) {
pnew = vim_strnsave(new, (size_t)len + 2);
pnew = xstrnsave(new, (size_t)len + 2);
pnew[len] = ' ';
pnew[len + 1] = NUL;
ml_replace(curwin->w_cursor.lnum, (char *)pnew, false);
ml_replace(curwin->w_cursor.lnum, pnew, false);
// remove the space later
did_add_space = true;
} else {
@ -1026,7 +1026,7 @@ void format_lines(linenr_T line_count, bool avoid_fex)
// paragraph doesn't really end.
if (next_leader_flags == NULL
|| STRNCMP(next_leader_flags, "://", 3) != 0
|| check_linecomment((char *)get_cursor_line_ptr()) == MAXCOL) {
|| check_linecomment(get_cursor_line_ptr()) == MAXCOL) {
is_end_par = true;
}
}

4
src/nvim/textobject.c
View File

@ -1032,7 +1032,7 @@ int current_block(oparg_T *oap, long count, bool include, int what, int other)
/// @return true if the cursor is on a "<aaa>" tag. Ignore "<aaa/>".
static bool in_html_tag(bool end_tag)
{
char_u *line = get_cursor_line_ptr();
char_u *line = (char_u *)get_cursor_line_ptr();
char_u *p;
int c;
int lc = NUL;
@ -1493,7 +1493,7 @@ static int find_prev_quote(char_u *line, int col_start, int quotechar, char_u *e
bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
FUNC_ATTR_NONNULL_ALL
{
char_u *line = get_cursor_line_ptr();
char_u *line = (char_u *)get_cursor_line_ptr();
int col_end;
int col_start = curwin->w_cursor.col;
bool inclusive = false;

9
src/nvim/viml/parser/expressions.c
View File

@ -66,8 +66,6 @@
#include "nvim/viml/parser/expressions.h"
#include "nvim/viml/parser/parser.h"
#define VIM_STR2NR(s, ...) vim_str2nr((const char_u *)(s), __VA_ARGS__)
typedef kvec_withinit_t(ExprASTNode **, 16) ExprASTStack;
/// Which nodes may be wanted
@ -371,7 +369,7 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
significand_part = significand_part * 10 + (pline.data[i] - '0');
}
if (exp_start) {
VIM_STR2NR(pline.data + exp_start, NULL, NULL, 0, NULL, &exp_part,
vim_str2nr(pline.data + exp_start, NULL, NULL, 0, NULL, &exp_part,
(int)(ret.len - exp_start), false);
}
if (exp_negative) {
@ -389,7 +387,7 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
} else {
int len;
int prep;
VIM_STR2NR(pline.data, &prep, &len, STR2NR_ALL, NULL,
vim_str2nr(pline.data, &prep, &len, STR2NR_ALL, NULL,
&ret.data.num.val.integer, (int)pline.size, false);
ret.len = (size_t)len;
const uint8_t bases[] = {
@ -696,8 +694,7 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
// Everything else is not valid.
default:
ret.len = (size_t)utfc_ptr2len_len((const char_u *)pline.data,
(int)pline.size);
ret.len = (size_t)utfc_ptr2len_len(pline.data, (int)pline.size);
ret.type = kExprLexInvalid;
ret.data.err.type = kExprLexPlainIdentifier;
ret.data.err.msg = _("E15: Unidentified character: %.*s");

6
src/nvim/window.c
View File

@ -6524,7 +6524,7 @@ char_u *grab_file_name(long count, linenr_T *file_lnum)
*file_lnum = (linenr_T)getdigits_long(&p, false, 0);
}
return find_file_name_in_path((char_u *)ptr, len, options, count, (char_u *)curbuf->b_ffname);
return (char_u *)find_file_name_in_path(ptr, len, options, count, curbuf->b_ffname);
}
return file_name_at_cursor(options | FNAME_HYP, count, file_lnum);
}
@ -6544,7 +6544,7 @@ char_u *grab_file_name(long count, linenr_T *file_lnum)
*/
char_u *file_name_at_cursor(int options, long count, linenr_T *file_lnum)
{
return file_name_in_line(get_cursor_line_ptr(),
return file_name_in_line((char_u *)get_cursor_line_ptr(),
curwin->w_cursor.col, options, count, (char_u *)curbuf->b_ffname,
file_lnum);
}
@ -6651,7 +6651,7 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
}
}
return find_file_name_in_path((char_u *)ptr, len, options, count, rel_fname);
return (char_u *)find_file_name_in_path(ptr, len, options, count, (char *)rel_fname);
}
/// Add or remove a status line from window(s), according to the