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

vim-patch:9.1.0172: More code can use ml_get_buf_len() instead of STRLEN()

Browse Source 
Problem:  More code can use ml_get_buf_len() instead of STRLEN().
Solution: Change more STRLEN() calls to ml_get_buf_len().  Also do not
          set ml_line_textlen in ml_replace_len() if "has_props" is set,
          because "len_arg" also includes the size of text properties in
          that case. (zeertzjq)

closes: vim/vim#14183

94b7c3233e
This commit is contained in:
zeertzjq
2024-03-13 15:00:43 +08:00
parent 3502aa63f0
commit 090d1fd0b8
22 changed files with 148 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/nvim/change.c
View File

@@ -1044,7 +1044,7 @@ bool copy_indent(int size, char *src)
if (p == NULL) {
// Allocate memory for the result: the copied indent, new indent
// and the rest of the line.
line_len = (int)strlen(get_cursor_line_ptr()) + 1;
line_len = get_cursor_line_len() + 1;
assert(ind_len + line_len >= 0);
size_t line_size;
STRICT_ADD(ind_len, line_len, &line_size, size_t);
@@ -1865,7 +1865,7 @@ bool open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
}
if (did_append) {
// bail out and just get the final length of the line we just manipulated
bcount_t extra = (bcount_t)strlen(ml_get(curwin->w_cursor.lnum));
bcount_t extra = ml_get_len(curwin->w_cursor.lnum);
extmark_splice(curbuf, (int)curwin->w_cursor.lnum - 1, 0,
0, 0, 0, 1, 0, 1 + extra, kExtmarkUndo);
changed_lines(curbuf, curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1, true);

11
src/nvim/cursor.c
View File

@@ -108,9 +108,10 @@ static int coladvance2(win_T *wp, pos_T *pos, bool addspaces, bool finetune, col
|| ((get_ve_flags(wp) & VE_ONEMORE) && wcol < MAXCOL);
char *line = ml_get_buf(wp->w_buffer, pos->lnum);
int linelen = ml_get_buf_len(wp->w_buffer, pos->lnum);
if (wcol >= MAXCOL) {
idx = (int)strlen(line) - 1 + one_more;
idx = linelen - 1 + one_more;
col = wcol;
if ((addspaces || finetune) && !VIsual_active) {
@@ -188,7 +189,6 @@ static int coladvance2(win_T *wp, pos_T *pos, bool addspaces, bool finetune, col
col = wcol;
} else {
// Break a tab
int linelen = (int)strlen(line);
int correct = wcol - col - csize + 1; // negative!!
char *newline;
@@ -315,8 +315,7 @@ void check_pos(buf_T *buf, pos_T *pos)
}
if (pos->col > 0) {
char *line = ml_get_buf(buf, pos->lnum);
colnr_T len = (colnr_T)strlen(line);
colnr_T len = ml_get_buf_len(buf, pos->lnum);
if (pos->col > len) {
pos->col = len;
}
@@ -347,7 +346,7 @@ void check_cursor_col(win_T *win)
colnr_T oldcoladd = win->w_cursor.col + win->w_cursor.coladd;
unsigned cur_ve_flags = get_ve_flags(win);
colnr_T len = (colnr_T)strlen(ml_get_buf(win->w_buffer, win->w_cursor.lnum));
colnr_T len = ml_get_buf_len(win->w_buffer, win->w_cursor.lnum);
if (len == 0) {
win->w_cursor.col = 0;
} else if (win->w_cursor.col >= len) {
@@ -413,7 +412,7 @@ void check_visual_pos(void)
VIsual.col = 0;
VIsual.coladd = 0;
} else {
int len = (int)strlen(ml_get(VIsual.lnum));
int len = ml_get_len(VIsual.lnum);
if (VIsual.col > len) {
VIsual.col = len;

2
src/nvim/diff.c
View File

@@ -756,7 +756,7 @@ static int diff_write_buffer(buf_T *buf, mmfile_t *m, linenr_T start, linenr_T e
// xdiff requires one big block of memory with all the text.
for (linenr_T lnum = start; lnum <= end; lnum++) {
len += strlen(ml_get_buf(buf, lnum)) + 1;
len += (size_t)ml_get_buf_len(buf, lnum) + 1;
}
char *ptr = try_malloc(len);
if (ptr == NULL) {

69
src/nvim/drawline.c
View File

@@ -850,43 +850,6 @@ static void handle_inline_virtual_text(win_T *wp, winlinevars_T *wlv, ptrdiff_t
}
}
static colnr_T get_trailcol(win_T *wp, const char *ptr, const char *line)
{
colnr_T trailcol = MAXCOL;
// find start of trailing whitespace
if (wp->w_p_lcs_chars.trail) {
trailcol = (colnr_T)strlen(ptr);
while (trailcol > 0 && ascii_iswhite(ptr[trailcol - 1])) {
trailcol--;
}
trailcol += (colnr_T)(ptr - line);
}
return trailcol;
}
static colnr_T get_leadcol(win_T *wp, const char *ptr, const char *line)
{
colnr_T leadcol = 0;
// find end of leading whitespace
if (wp->w_p_lcs_chars.lead || wp->w_p_lcs_chars.leadmultispace != NULL) {
leadcol = 0;
while (ascii_iswhite(ptr[leadcol])) {
leadcol++;
}
if (ptr[leadcol] == NUL) {
// in a line full of spaces all of them are treated as trailing
leadcol = 0;
} else {
// keep track of the first column not filled with spaces
leadcol += (colnr_T)(ptr - line + 1);
}
}
return leadcol;
}
/// Start a screen line at column zero.
static void win_line_start(win_T *wp, winlinevars_T *wlv)
{
@@ -1298,17 +1261,17 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, s
nextlinecol = MAXCOL;
nextline_idx = 0;
} else {
const size_t line_len = strlen(line);
const colnr_T line_len = ml_get_buf_len(wp->w_buffer, lnum);
if (line_len < SPWORDLEN) {
// Short line, use it completely and append the start of the
// next line.
nextlinecol = 0;
memmove(nextline, line, line_len);
memmove(nextline, line, (size_t)line_len);
STRMOVE(nextline + line_len, nextline + SPWORDLEN);
nextline_idx = (int)line_len + 1;
nextline_idx = line_len + 1;
} else {
// Long line, use only the last SPWORDLEN bytes.
nextlinecol = (int)line_len - SPWORDLEN;
nextlinecol = line_len - SPWORDLEN;
memmove(nextline, line + nextlinecol, SPWORDLEN);
nextline_idx = SPWORDLEN + 1;
}
@@ -1336,8 +1299,28 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, s
|| wp->w_p_lcs_chars.nbsp) {
extra_check = true;
}
trailcol = get_trailcol(wp, ptr, line);
leadcol = get_leadcol(wp, ptr, line);
// find start of trailing whitespace
if (wp->w_p_lcs_chars.trail) {
trailcol = ml_get_buf_len(wp->w_buffer, lnum);
while (trailcol > 0 && ascii_iswhite(ptr[trailcol - 1])) {
trailcol--;
}
trailcol += (colnr_T)(ptr - line);
}
// find end of leading whitespace
if (wp->w_p_lcs_chars.lead || wp->w_p_lcs_chars.leadmultispace != NULL) {
leadcol = 0;
while (ascii_iswhite(ptr[leadcol])) {
leadcol++;
}
if (ptr[leadcol] == NUL) {
// in a line full of spaces all of them are treated as trailing
leadcol = 0;
} else {
// keep track of the first column not filled with spaces
leadcol += (colnr_T)(ptr - line + 1);
}
}
}
// 'nowrap' or 'wrap' and a single line that doesn't fit: Advance to the

8
src/nvim/edit.c
View File

@@ -2968,7 +2968,7 @@ static void replace_do_bs(int limit_col)
}
del_char_after_col(limit_col);
if (l_State & VREPLACE_FLAG) {
orig_len = (int)strlen(get_cursor_pos_ptr());
orig_len = get_cursor_pos_len();
}
replace_push(cc);
replace_pop_ins();
@@ -2976,7 +2976,7 @@ static void replace_do_bs(int limit_col)
if (l_State & VREPLACE_FLAG) {
// Get the number of screen cells used by the inserted characters
char *p = get_cursor_pos_ptr();
int ins_len = (int)strlen(p) - orig_len;
int ins_len = get_cursor_pos_len() - orig_len;
int vcol = start_vcol;
for (int i = 0; i < ins_len; i++) {
vcol += win_chartabsize(curwin, p + i, vcol);
@@ -3760,7 +3760,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
return false;
}
Insstart.lnum--;
Insstart.col = (colnr_T)strlen(ml_get(Insstart.lnum));
Insstart.col = ml_get_len(Insstart.lnum);
}
// In replace mode:
// cc < 0: NL was inserted, delete it
@@ -4480,7 +4480,7 @@ bool ins_eol(int c)
// NL in reverse insert will always start in the end of current line.
if (revins_on) {
curwin->w_cursor.col += (colnr_T)strlen(get_cursor_pos_ptr());
curwin->w_cursor.col += get_cursor_pos_len();
}
AppendToRedobuff(NL_STR);

35
src/nvim/ex_cmds.c
View File

@@ -541,7 +541,7 @@ void ex_sort(exarg_T *eap)
// Also get the longest line length for allocating "sortbuf".
for (linenr_T lnum = eap->line1; lnum <= eap->line2; lnum++) {
char *s = ml_get(lnum);
int len = (int)strlen(s);
int len = ml_get_len(lnum);
if (maxlen < len) {
maxlen = len;
}
@@ -643,8 +643,8 @@ void ex_sort(exarg_T *eap)
}
char *s = ml_get(get_lnum);
size_t bytelen = strlen(s) + 1; // include EOL in bytelen
old_count += (bcount_t)bytelen;
colnr_T bytelen = ml_get_len(get_lnum) + 1; // include EOL in bytelen
old_count += bytelen;
if (!unique || i == 0 || string_compare(s, sortbuf1) != 0) {
// Copy the line into a buffer, it may become invalid in
// ml_append(). And it's needed for "unique".
@@ -652,7 +652,7 @@ void ex_sort(exarg_T *eap)
if (ml_append(lnum++, sortbuf1, 0, false) == FAIL) {
break;
}
new_count += (bcount_t)bytelen;
new_count += bytelen;
}
fast_breakcheck();
if (got_int) {
@@ -740,7 +740,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
return FAIL;
}
for (extra = 0, l = line1; l <= line2; l++) {
char *str = xstrdup(ml_get(l + extra));
char *str = xstrnsave(ml_get(l + extra), (size_t)ml_get_len(l + extra));
ml_append(dest + l - line1, str, 0, false);
xfree(str);
if (dest < line1) {
@@ -876,9 +876,8 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
curwin->w_cursor.lnum = n;
while (line1 <= line2) {
// need to use xstrdup() because the line will be unlocked within
// ml_append()
char *p = xstrdup(ml_get(line1));
// need to make a copy because the line will be unlocked within ml_append()
char *p = xstrnsave(ml_get(line1), (size_t)ml_get_len(line1));
ml_append(curwin->w_cursor.lnum, p, 0, false);
xfree(p);
@@ -3300,7 +3299,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n
if (nmatch > 1) { \
sub_firstlnum += (linenr_T)nmatch - 1; \
xfree(sub_firstline); \
sub_firstline = xstrdup(ml_get(sub_firstlnum)); \
sub_firstline = xstrnsave(ml_get(sub_firstlnum), \
(size_t)ml_get_len(sub_firstlnum)); \
/* When going beyond the last line, stop substituting. */ \
if (sub_firstlnum <= line2) { \
do_again = true; \
@@ -3628,7 +3628,8 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n
break;
}
if (sub_firstline == NULL) {
sub_firstline = xstrdup(ml_get(sub_firstlnum));
sub_firstline = xstrnsave(ml_get(sub_firstlnum),
(size_t)ml_get_len(sub_firstlnum));
}
// Save the line number of the last change for the final
@@ -3765,7 +3766,7 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n
// really update the line, it would change
// what matches. Temporarily replace the line
// and change it back afterwards.
orig_line = xstrdup(ml_get(lnum));
orig_line = xstrnsave(ml_get(lnum), (size_t)ml_get_len(lnum));
char *new_line = concat_str(new_start, sub_firstline + copycol);
// Position the cursor relative to the end of the line, the
@@ -4626,8 +4627,8 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
}
char *str = NULL; // construct the line to show in here
size_t old_line_size = 0;
size_t line_size = 0;
colnr_T old_line_size = 0;
colnr_T line_size = 0;
linenr_T linenr_preview = 0; // last line added to preview buffer
linenr_T linenr_origbuf = 0; // last line added to original buffer
linenr_T next_linenr = 0; // next line to show for the match
@@ -4666,21 +4667,21 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
line = "";
} else {
line = ml_get_buf(orig_buf, next_linenr);
line_size = strlen(line) + (size_t)col_width + 1;
line_size = ml_get_buf_len(orig_buf, next_linenr) + col_width + 1;
// Reallocate if line not long enough
if (line_size > old_line_size) {
str = xrealloc(str, line_size * sizeof(char));
str = xrealloc(str, (size_t)line_size * sizeof(char));
old_line_size = line_size;
}
}
// Put "|lnum| line" into `str` and append it to the preview buffer.
snprintf(str, line_size, "|%*" PRIdLINENR "| %s", col_width - 3,
snprintf(str, (size_t)line_size, "|%*" PRIdLINENR "| %s", col_width - 3,
next_linenr, line);
if (linenr_preview == 0) {
ml_replace_buf(cmdpreview_buf, 1, str, true, false);
} else {
ml_append_buf(cmdpreview_buf, linenr_preview, str, (colnr_T)line_size, false);
ml_append_buf(cmdpreview_buf, linenr_preview, str, line_size, false);
}
linenr_preview += 1;
}

2
src/nvim/fileio.c
View File

@@ -957,7 +957,7 @@ retry:
int tlen = 0;
while (true) {
p = (uint8_t *)ml_get(read_buf_lnum) + read_buf_col;
int n = (int)strlen((char *)p);
int n = ml_get_len(read_buf_lnum) - read_buf_col;
if (tlen + n + 1 > size) {
// Filled up to "size", append partial line.
// Change NL to NUL to reverse the effect done

7
src/nvim/fold.c
View File

@@ -1017,8 +1017,7 @@ void foldAdjustVisual(void)
return;
}
char *ptr = ml_get(end->lnum);
end->col = (colnr_T)strlen(ptr);
end->col = ml_get_len(end->lnum);
if (end->col > 0 && *p_sel == 'o') {
end->col--;
}
@@ -1605,7 +1604,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char *marker, size_t mark
// Allocate a new line: old-line + 'cms'-start + marker + 'cms'-end
char *line = ml_get_buf(buf, lnum);
size_t line_len = strlen(line);
size_t line_len = (size_t)ml_get_buf_len(buf, lnum);
size_t added = 0;
if (u_save(lnum - 1, lnum + 1) != OK) {
@@ -1686,7 +1685,7 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char *marker, size_t marker
}
if (u_save(lnum - 1, lnum + 1) == OK) {
// Make new line: text-before-marker + text-after-marker
char *newline = xmalloc(strlen(line) - len + 1);
char *newline = xmalloc((size_t)ml_get_buf_len(buf, lnum) - len + 1);
assert(p >= line);
memcpy(newline, line, (size_t)(p - line));
STRCPY(newline + (p - line), p + len);

2
src/nvim/insexpand.c
View File

@@ -2937,7 +2937,7 @@ static int process_next_cpt_value(ins_compl_next_state_T *st, int *compl_type_ar
// buffer, so that word at start of buffer is found
// correctly.
st->first_match_pos.lnum = st->ins_buf->b_ml.ml_line_count;
st->first_match_pos.col = (colnr_T)strlen(ml_get(st->first_match_pos.lnum));
st->first_match_pos.col = ml_get_len(st->first_match_pos.lnum);
}
st->last_match_pos = st->first_match_pos;
compl_type = 0;

2
src/nvim/mark.c
View File

@@ -1715,7 +1715,7 @@ void mark_mb_adjustpos(buf_T *buf, pos_T *lp)
{
if (lp->col > 0 || lp->coladd > 1) {
const char *const p = ml_get_buf(buf, lp->lnum);
if (*p == NUL || (int)strlen(p) < lp->col) {
if (*p == NUL || ml_get_buf_len(buf, lp->lnum) < lp->col) {
lp->col = 0;
} else {
lp->col -= utf_head_off(p, p + lp->col);

10
src/nvim/memline.c
View File

@@ -1840,6 +1840,12 @@ colnr_T ml_get_len(linenr_T lnum)
return ml_get_buf_len(curbuf, lnum);
}
/// @return length (excluding the NUL) of the text after position "pos".
colnr_T ml_get_pos_len(pos_T *pos)
{
return ml_get_buf_len(curbuf, curwin->w_cursor.lnum) - pos->col;
}
/// @return length (excluding the NUL) of the given line in the given buffer.
colnr_T ml_get_buf_len(buf_T *buf, linenr_T lnum)
{
@@ -4133,7 +4139,7 @@ int dec(pos_T *lp)
if (lp->col == MAXCOL) {
// past end of line
char *p = ml_get(lp->lnum);
lp->col = (colnr_T)strlen(p);
lp->col = ml_get_len(lp->lnum);
lp->col -= utf_head_off(p, p + lp->col);
return 0;
}
@@ -4149,7 +4155,7 @@ int dec(pos_T *lp)
// there is a prior line
lp->lnum--;
char *p = ml_get(lp->lnum);
lp->col = (colnr_T)strlen(p);
lp->col = ml_get_len(lp->lnum);
lp->col -= utf_head_off(p, p + lp->col);
return 1;
}

92
src/nvim/ops.c
View File

@@ -266,7 +266,7 @@ void op_shift(oparg_T *oap, bool curs_top, int amount)
// Set "'[" and "']" marks.
curbuf->b_op_start = oap->start;
curbuf->b_op_end.lnum = oap->end.lnum;
curbuf->b_op_end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
curbuf->b_op_end.col = ml_get_len(oap->end.lnum);
if (curbuf->b_op_end.col > 0) {
curbuf->b_op_end.col--;
}
@@ -564,8 +564,8 @@ static void block_insert(oparg_T *oap, char *s, bool b_insert, struct block_def
assert(count >= 0);
// Make sure the allocated size matches what is actually copied below.
newp = xmalloc(strlen(oldp) + (size_t)spaces + s_len
+ (spaces > 0 && !bdp->is_short ? (size_t)ts_val - (size_t)spaces : 0)
newp = xmalloc((size_t)ml_get_len(lnum) + (size_t)spaces + s_len
+ (spaces > 0 && !bdp->is_short ? (size_t)(ts_val - spaces) : 0)
+ (size_t)count + 1);
// copy up to shifted part
@@ -1572,7 +1572,7 @@ int op_delete(oparg_T *oap)
// Thus the number of characters may increase!
int n = bd.textlen - bd.startspaces - bd.endspaces;
char *oldp = ml_get(lnum);
char *newp = xmalloc(strlen(oldp) - (size_t)n + 1);
char *newp = xmalloc((size_t)ml_get_len(lnum) - (size_t)n + 1);
// copy up to deleted part
memmove(newp, oldp, (size_t)bd.textcol);
// insert spaces
@@ -1681,8 +1681,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 *curline = get_cursor_line_ptr();
int len = (int)strlen(curline);
int len = get_cursor_line_len();
if (oap->end.coladd != 0
&& (int)oap->end.col >= len - 1
@@ -1875,7 +1874,7 @@ static int op_replace(oparg_T *oap, int c)
numc *= utf_char2len(c);
char *oldp = get_cursor_line_ptr();
colnr_T oldlen = (int)strlen(oldp);
colnr_T oldlen = get_cursor_line_len();
size_t newp_size = (size_t)bd.textcol + (size_t)bd.startspaces;
if (had_ctrl_v_cr || (c != '\r' && c != '\n')) {
@@ -1939,7 +1938,7 @@ static int op_replace(oparg_T *oap, int c)
if (oap->motion_type == kMTLineWise) {
oap->start.col = 0;
curwin->w_cursor.col = 0;
oap->end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
oap->end.col = ml_get_len(oap->end.lnum);
if (oap->end.col) {
oap->end.col--;
}
@@ -2058,7 +2057,7 @@ void op_tilde(oparg_T *oap)
if (oap->motion_type == kMTLineWise) {
oap->start.col = 0;
pos.col = 0;
oap->end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
oap->end.col = ml_get_len(oap->end.lnum);
if (oap->end.col) {
oap->end.col--;
}
@@ -2073,7 +2072,7 @@ void op_tilde(oparg_T *oap)
while (true) {
did_change |= swapchars(oap->op_type, &pos,
pos.lnum == oap->end.lnum ? oap->end.col + 1
: (int)strlen(ml_get_pos(&pos)));
: ml_get_pos_len(&pos));
if (ltoreq(oap->end, pos) || inc(&pos) == -1) {
break;
}
@@ -2232,12 +2231,11 @@ void op_insert(oparg_T *oap, int count1)
// Get indent information
ind_pre_col = (colnr_T)getwhitecols_curline();
ind_pre_vcol = get_indent();
char *firstline = ml_get(oap->start.lnum) + bd.textcol;
pre_textlen = ml_get_len(oap->start.lnum) - bd.textcol;
if (oap->op_type == OP_APPEND) {
firstline += bd.textlen;
pre_textlen -= bd.textlen;
}
pre_textlen = (int)strlen(firstline);
}
if (oap->op_type == OP_APPEND) {
@@ -2364,7 +2362,7 @@ void op_insert(oparg_T *oap, int count1)
// Subsequent calls to ml_get() flush the firstline data - take a
// copy of the required string.
char *firstline = ml_get(oap->start.lnum);
const size_t len = strlen(firstline);
colnr_T len = ml_get_len(oap->start.lnum);
colnr_T add = bd.textcol;
colnr_T offset = 0; // offset when cursor was moved in insert mode
if (oap->op_type == OP_APPEND) {
@@ -2381,12 +2379,12 @@ void op_insert(oparg_T *oap, int count1)
}
}
}
if ((size_t)add > len) {
firstline += len; // short line, point to the NUL
} else {
firstline += add;
if (add > len) {
add = len; // short line, point to the NUL
}
int ins_len = (int)strlen(firstline) - pre_textlen - offset;
firstline += add;
len -= add;
int ins_len = len - pre_textlen - offset;
if (pre_textlen >= 0 && ins_len > 0) {
char *ins_text = xmemdupz(firstline, (size_t)ins_len);
// block handled here
@@ -2441,7 +2439,7 @@ int op_change(oparg_T *oap)
coladvance_force(getviscol());
}
firstline = ml_get(oap->start.lnum);
pre_textlen = (int)strlen(firstline);
pre_textlen = ml_get_len(oap->start.lnum);
pre_indent = (int)getwhitecols(firstline);
bd.textcol = curwin->w_cursor.col;
}
@@ -2474,7 +2472,7 @@ int op_change(oparg_T *oap)
bd.textcol += (colnr_T)(new_indent - pre_indent);
}
ins_len = (int)strlen(firstline) - pre_textlen;
ins_len = ml_get_len(oap->start.lnum) - pre_textlen;
if (ins_len > 0) {
// Subsequent calls to ml_get() flush the firstline data - take a
// copy of the inserted text.
@@ -2495,8 +2493,8 @@ int op_change(oparg_T *oap)
vpos.coladd = 0;
}
char *oldp = ml_get(linenr);
char *newp = xmalloc(strlen(oldp) + (size_t)vpos.coladd
+ (size_t)ins_len + 1);
char *newp = xmalloc((size_t)ml_get_len(linenr)
+ (size_t)vpos.coladd + (size_t)ins_len + 1);
// copy up to block start
memmove(newp, oldp, (size_t)bd.textcol);
int offset = bd.textcol;
@@ -3173,6 +3171,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
}
// get the old line and advance to the position to insert at
char *oldp = get_cursor_line_ptr();
colnr_T oldlen = get_cursor_line_len();
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, curwin->w_cursor.lnum, oldp);
@@ -3183,7 +3182,6 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
vcol += incr;
ci = utfc_next(ci);
}
size_t oldlen = (size_t)(ci.ptr - oldp) + strlen(ci.ptr);
char *ptr = ci.ptr;
bd.textcol = (colnr_T)(ptr - oldp);
@@ -3233,7 +3231,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
totlen = (size_t)count * (size_t)(yanklen + spaces) + (size_t)bd.startspaces +
(size_t)bd.endspaces;
char *newp = xmalloc(totlen + oldlen + 1);
char *newp = xmalloc(totlen + (size_t)oldlen + 1);
// copy part up to cursor to new line
ptr = newp;
@@ -3263,7 +3261,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
ptr += bd.endspaces;
// move the text after the cursor to the end of the line.
int columns = (int)oldlen - bd.textcol - delcount + 1;
int columns = oldlen - bd.textcol - delcount + 1;
assert(columns >= 0);
memmove(ptr, oldp + bd.textcol + delcount, (size_t)columns);
ml_replace(curwin->w_cursor.lnum, newp, false);
@@ -3295,7 +3293,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
curwin->w_cursor.col++;
// in Insert mode we might be after the NUL, correct for that
colnr_T len = (colnr_T)strlen(get_cursor_line_ptr());
colnr_T len = get_cursor_line_len();
if (curwin->w_cursor.col > len) {
curwin->w_cursor.col = len;
}
@@ -3359,7 +3357,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
totlen = (size_t)count * (size_t)yanklen;
do {
char *oldp = ml_get(lnum);
size_t oldlen = strlen(oldp);
colnr_T oldlen = ml_get_len(lnum);
if (lnum > start_lnum) {
pos_T pos = {
.lnum = lnum,
@@ -3370,11 +3368,11 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
col = MAXCOL;
}
}
if (VIsual_active && col > (colnr_T)oldlen) {
if (VIsual_active && col > oldlen) {
lnum++;
continue;
}
char *newp = xmalloc(totlen + oldlen + 1);
char *newp = xmalloc(totlen + (size_t)oldlen + 1);
memmove(newp, oldp, (size_t)col);
char *ptr = newp + col;
for (size_t i = 0; i < (size_t)count; i++) {
@@ -3431,7 +3429,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
lnum = new_cursor.lnum;
char *ptr = ml_get(lnum) + col;
totlen = strlen(y_array[y_size - 1]);
char *newp = xmalloc((size_t)(strlen(ptr) + totlen + 1));
char *newp = xmalloc((size_t)ml_get_len(lnum) - (size_t)col + totlen + 1);
STRCPY(newp, y_array[y_size - 1]);
STRCAT(newp, ptr);
// insert second line
@@ -3465,7 +3463,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
curwin->w_cursor.lnum = lnum;
char *ptr = ml_get(lnum);
if (cnt == count && i == y_size - 1) {
lendiff = (int)strlen(ptr);
lendiff = ml_get_len(lnum);
}
if (*ptr == '#' && preprocs_left()) {
indent = 0; // Leave # lines at start
@@ -3482,7 +3480,7 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
curwin->w_cursor = old_pos;
// remember how many chars were removed
if (cnt == count && i == y_size - 1) {
lendiff -= (int)strlen(ml_get(lnum));
lendiff -= ml_get_len(lnum);
}
}
}
@@ -3588,7 +3586,7 @@ error:
curwin->w_set_curswant = true;
// Make sure the cursor is not after the NUL.
int len = (int)strlen(get_cursor_line_ptr());
int len = get_cursor_line_len();
if (curwin->w_cursor.col > len) {
if (cur_ve_flags == VE_ALL) {
curwin->w_cursor.coladd = curwin->w_cursor.col - len;
@@ -4301,7 +4299,7 @@ void charwise_block_prep(pos_T start, pos_T end, struct block_def *bdp, linenr_T
}
}
if (endcol == MAXCOL) {
endcol = (colnr_T)strlen(p);
endcol = ml_get_len(lnum);
}
if (startcol > endcol || is_oneChar) {
bdp->textlen = 0;
@@ -4358,20 +4356,20 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
} else if (oap->motion_type == kMTLineWise) {
curwin->w_cursor.col = 0;
pos.col = 0;
length = (colnr_T)strlen(ml_get(pos.lnum));
length = ml_get_len(pos.lnum);
} else {
// oap->motion_type == kMTCharWise
if (pos.lnum == oap->start.lnum && !oap->inclusive) {
dec(&(oap->end));
}
length = (colnr_T)strlen(ml_get(pos.lnum));
length = ml_get_len(pos.lnum);
pos.col = 0;
if (pos.lnum == oap->start.lnum) {
pos.col += oap->start.col;
length -= oap->start.col;
}
if (pos.lnum == oap->end.lnum) {
length = (int)strlen(ml_get(oap->end.lnum));
length = ml_get_len(oap->end.lnum);
if (oap->end.col >= length) {
oap->end.col = length - 1;
}
@@ -5443,7 +5441,7 @@ void cursor_pos_info(dict_T *dict)
validate_virtcol(curwin);
col_print(buf1, sizeof(buf1), (int)curwin->w_cursor.col + 1,
(int)curwin->w_virtcol + 1);
col_print(buf2, sizeof(buf2), (int)strlen(p), linetabsize_str(p));
col_print(buf2, sizeof(buf2), get_cursor_line_len(), linetabsize_str(p));
if (char_count_cursor == byte_count_cursor
&& char_count == byte_count) {
@@ -5857,11 +5855,10 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
&& cap->oap->op_type != OP_DELETE) {
if (lt(VIsual, curwin->w_cursor)) {
VIsual.col = 0;
curwin->w_cursor.col =
(colnr_T)strlen(ml_get(curwin->w_cursor.lnum));
curwin->w_cursor.col = ml_get_len(curwin->w_cursor.lnum);
} else {
curwin->w_cursor.col = 0;
VIsual.col = (colnr_T)strlen(ml_get(VIsual.lnum));
VIsual.col = ml_get_len(VIsual.lnum);
}
VIsual_mode = 'v';
} else if (VIsual_mode == 'v') {
@@ -5890,7 +5887,7 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
|| oap->motion_type == kMTLineWise)
&& hasFolding(curwin, curwin->w_cursor.lnum, NULL,
&curwin->w_cursor.lnum)) {
curwin->w_cursor.col = (colnr_T)strlen(get_cursor_line_ptr());
curwin->w_cursor.col = get_cursor_line_len();
}
}
oap->end = curwin->w_cursor;
@@ -5908,7 +5905,7 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
curwin->w_cursor.col = 0;
}
if (hasFolding(curwin, oap->start.lnum, NULL, &oap->start.lnum)) {
oap->start.col = (colnr_T)strlen(ml_get(oap->start.lnum));
oap->start.col = ml_get_len(oap->start.lnum);
}
}
oap->end = oap->start;
@@ -6092,7 +6089,7 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
if (inindent(0)) {
oap->motion_type = kMTLineWise;
} else {
oap->end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
oap->end.col = ml_get_len(oap->end.lnum);
if (oap->end.col) {
oap->end.col--;
oap->inclusive = true;
@@ -6866,14 +6863,13 @@ bcount_t get_region_bytecount(buf_T *buf, linenr_T start_lnum, linenr_T end_lnum
if (start_lnum == end_lnum) {
return end_col - start_col;
}
const char *first = ml_get_buf(buf, start_lnum);
bcount_t deleted_bytes = (bcount_t)strlen(first) - start_col + 1;
bcount_t deleted_bytes = ml_get_buf_len(buf, start_lnum) - start_col + 1;
for (linenr_T i = 1; i <= end_lnum - start_lnum - 1; i++) {
if (start_lnum + i > max_lnum) {
return deleted_bytes;
}
deleted_bytes += (bcount_t)strlen(ml_get_buf(buf, start_lnum + i)) + 1;
deleted_bytes += ml_get_buf_len(buf, start_lnum + i) + 1;
}
if (end_lnum > max_lnum) {
return deleted_bytes;

2
src/nvim/plines.c
View File

@@ -593,7 +593,7 @@ void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *e
// Cannot put the cursor on part of a wide character.
char *ptr = ml_get_buf(wp->w_buffer, pos->lnum);
if (pos->col < (colnr_T)strlen(ptr)) {
if (pos->col < ml_get_buf_len(wp->w_buffer, pos->lnum)) {
int c = utf_ptr2char(ptr + pos->col);
if ((c != TAB) && vim_isprintc(c)) {
endadd = (colnr_T)(char2cells(c) - 1);

7
src/nvim/quickfix.c
View File

@@ -773,9 +773,9 @@ static int qf_get_next_buf_line(qfstate_T *state)
return QF_END_OF_INPUT;
}
char *p_buf = ml_get_buf(state->buf, state->buflnum);
size_t len = (size_t)ml_get_buf_len(state->buf, state->buflnum);
state->buflnum += 1;
size_t len = strlen(p_buf);
if (len > IOSIZE - 2) {
state->linebuf = qf_grow_linebuf(state, len);
} else {
@@ -5356,12 +5356,13 @@ static bool vgr_match_buflines(qf_list_T *qfl, char *fname, buf_T *buf, char *sp
break;
}
col = regmatch->endpos[0].col + (col == regmatch->endpos[0].col);
if (col > (colnr_T)strlen(ml_get_buf(buf, lnum))) {
if (col > ml_get_buf_len(buf, lnum)) {
break;
}
}
} else {
char *const str = ml_get_buf(buf, lnum);
const int line_len = ml_get_buf_len(buf, lnum);
int score;
uint32_t matches[MAX_FUZZY_MATCHES];
const size_t sz = sizeof(matches) / sizeof(matches[0]);
@@ -5400,7 +5401,7 @@ static bool vgr_match_buflines(qf_list_T *qfl, char *fname, buf_T *buf, char *sp
break;
}
col = (colnr_T)matches[pat_len - 1] + col + 1;
if (col > (colnr_T)strlen(str)) {
if (col > line_len) {
break;
}
}

14
src/nvim/search.c
View File

@@ -604,7 +604,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
&& pos->col < MAXCOL - 2) {
// Watch out for the "col" being MAXCOL - 2, used in a closed fold.
ptr = ml_get_buf(buf, pos->lnum);
if ((int)strlen(ptr) <= pos->col) {
if (ml_get_buf_len(buf, pos->lnum) <= pos->col) {
start_char_len = 1;
} else {
start_char_len = utfc_ptr2len(ptr + pos->col);
@@ -851,7 +851,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
if (endpos.col == 0) {
if (pos->lnum > 1) { // just in case
pos->lnum--;
pos->col = (colnr_T)strlen(ml_get_buf(buf, pos->lnum));
pos->col = ml_get_buf_len(buf, pos->lnum);
}
} else {
pos->col--;
@@ -969,7 +969,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
// A pattern like "\n\zs" may go past the last line.
if (pos->lnum > buf->b_ml.ml_line_count) {
pos->lnum = buf->b_ml.ml_line_count;
pos->col = (int)strlen(ml_get_buf(buf, pos->lnum));
pos->col = ml_get_buf_len(buf, pos->lnum);
if (pos->col > 0) {
pos->col--;
}
@@ -1554,7 +1554,7 @@ int searchc(cmdarg_T *cap, bool t_cmd)
char *p = get_cursor_line_ptr();
int col = curwin->w_cursor.col;
int len = (int)strlen(p);
int len = get_cursor_line_len();
while (count--) {
while (true) {
@@ -1958,7 +1958,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
}
linep = ml_get(pos.lnum);
pos.col = (colnr_T)strlen(linep); // pos.col on trailing NUL
pos.col = ml_get_len(pos.lnum); // pos.col on trailing NUL
do_quotes = -1;
line_breakcheck();
@@ -2105,7 +2105,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
}
if (pos.lnum > 1) {
ptr = ml_get(pos.lnum - 1);
if (*ptr && *(ptr + strlen(ptr) - 1) == '\\') {
if (*ptr && *(ptr + ml_get_len(pos.lnum - 1) - 1) == '\\') {
do_quotes = 1;
if (start_in_quotes == kNone) {
inquote = at_start;
@@ -2472,7 +2472,7 @@ int current_search(int count, bool forward)
} else { // try again from end of buffer
// searching backwards, so set pos to last line and col
pos.lnum = curwin->w_buffer->b_ml.ml_line_count;
pos.col = (colnr_T)strlen(ml_get(curwin->w_buffer->b_ml.ml_line_count));
pos.col = ml_get_len(curwin->w_buffer->b_ml.ml_line_count);
}
}
}

4
src/nvim/spell.c
View File

@@ -1342,7 +1342,7 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
while (!got_int) {
char *line = ml_get_buf(wp->w_buffer, lnum);
len = strlen(line);
len = (size_t)ml_get_buf_len(wp->w_buffer, lnum);
if (buflen < len + MAXWLEN + 2) {
xfree(buf);
buflen = len + MAXWLEN + 2;
@@ -2682,7 +2682,7 @@ void ex_spellrepall(exarg_T *eap)
char *line = get_cursor_line_ptr();
if (addlen <= 0
|| strncmp(line + curwin->w_cursor.col, repl_to, repl_to_len) != 0) {
char *p = xmalloc(strlen(line) + (size_t)addlen + 1);
char *p = xmalloc((size_t)get_cursor_line_len() + (size_t)addlen + 1);
memmove(p, line, (size_t)curwin->w_cursor.col);
STRCPY(p + curwin->w_cursor.col, repl_to);
STRCAT(p, line + curwin->w_cursor.col + repl_from_len);

7
src/nvim/spellfile.c
View File

@@ -5114,13 +5114,12 @@ static void sug_write(spellinfo_T *spin, char *fname)
for (linenr_T lnum = 1; lnum <= wcount; lnum++) {
// <sugline>: <sugnr> ... NUL
char *line = ml_get_buf(spin->si_spellbuf, lnum);
size_t len = strlen(line) + 1;
if (fwrite(line, len, 1, fd) == 0) {
int len = ml_get_buf_len(spin->si_spellbuf, lnum) + 1;
if (fwrite(line, (size_t)len, 1, fd) == 0) {
emsg(_(e_write));
goto theend;
}
assert((size_t)spin->si_memtot + len <= INT_MAX);
spin->si_memtot += (int)len;
spin->si_memtot += len;
}
// Write another byte to check for errors.

7
src/nvim/spellsuggest.c
View File

@@ -480,9 +480,8 @@ void spell_suggest(int count)
badlen++;
end_visual_mode();
// make sure we don't include the NUL at the end of the line
char *line = get_cursor_line_ptr();
if (badlen > (int)strlen(line) - (int)curwin->w_cursor.col) {
badlen = (int)strlen(line) - (int)curwin->w_cursor.col;
if (badlen > get_cursor_line_len() - curwin->w_cursor.col) {
badlen = get_cursor_line_len() - curwin->w_cursor.col;
}
// Find the start of the badly spelled word.
} else if (spell_move_to(curwin, FORWARD, true, true, NULL) == 0
@@ -514,7 +513,7 @@ void spell_suggest(int count)
int need_cap = check_need_cap(curwin, curwin->w_cursor.lnum, curwin->w_cursor.col);
// Make a copy of current line since autocommands may free the line.
char *line = xstrdup(get_cursor_line_ptr());
char *line = xstrnsave(get_cursor_line_ptr(), (size_t)get_cursor_line_len());
spell_suggest_timeout = 5000;
// Get the list of suggestions. Limit to 'lines' - 2 or the number in

6
src/nvim/statusline.c
View File

@@ -1002,11 +1002,11 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, OptIndex op
// Get the byte value now, in case we need it below. This is more
// efficient than making a copy of the line.
int byteval;
const size_t len = strlen(line_ptr);
if (wp->w_cursor.col > (colnr_T)len) {
const colnr_T len = ml_get_buf_len(wp->w_buffer, lnum);
if (wp->w_cursor.col > len) {
// Line may have changed since checking the cursor column, or the lnum
// was adjusted above.
wp->w_cursor.col = (colnr_T)len;
wp->w_cursor.col = len;
wp->w_cursor.coladd = 0;
byteval = 0;
} else {

10
src/nvim/syntax.c
View File

@@ -549,8 +549,8 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
// Skip lines that end in a backslash.
for (; start_lnum > 1; start_lnum--) {
char *line = ml_get(start_lnum - 1);
if (*line == NUL || *(line + strlen(line) - 1) != '\\') {
char *l = ml_get(start_lnum - 1);
if (*l == NUL || *(l + ml_get_len(start_lnum - 1) - 1) != '\\') {
break;
}
}
@@ -2352,7 +2352,6 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
regmmatch_T regmatch;
regmmatch_T best_regmatch; // startpos/endpos of best match
lpos_T pos;
char *line;
bool had_match = false;
char buf_chartab[32]; // chartab array for syn option iskeyword
@@ -2457,8 +2456,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
break;
}
line = ml_get_buf(syn_buf, startpos->lnum);
int line_len = (int)strlen(line);
int line_len = ml_get_buf_len(syn_buf, startpos->lnum);
// take care of an empty match or negative offset
if (pos.col <= matchcol) {
@@ -2635,7 +2633,7 @@ static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *s
if (result->lnum > syn_buf->b_ml.ml_line_count) {
// a "\n" at the end of the pattern may take us below the last line
result->lnum = syn_buf->b_ml.ml_line_count;
col = (int)strlen(ml_get_buf(syn_buf, result->lnum));
col = ml_get_buf_len(syn_buf, result->lnum);
}
if (off != 0) {
base = ml_get_buf(syn_buf, result->lnum);

13
src/nvim/textformat.c
View File

@@ -445,7 +445,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
// Check if cursor is not past the NUL off the line, cindent
// may have added or removed indent.
curwin->w_cursor.col += startcol;
colnr_T len = (colnr_T)strlen(get_cursor_line_ptr());
colnr_T len = get_cursor_line_len();
if (curwin->w_cursor.col > len) {
curwin->w_cursor.col = len;
}
@@ -506,12 +506,11 @@ static int fmt_check_par(linenr_T lnum, int *leader_len, char **leader_flags, bo
static bool ends_in_white(linenr_T lnum)
{
char *s = ml_get(lnum);
size_t l;
if (*s == NUL) {
return false;
}
l = strlen(s) - 1;
colnr_T l = ml_get_len(lnum) - 1;
return ascii_iswhite((uint8_t)s[l]);
}
@@ -544,7 +543,7 @@ static bool same_leader(linenr_T lnum, int leader1_len, char *leader1_flags, int
return false;
}
if (*p == COM_START) {
int line_len = (int)strlen(ml_get(lnum));
int line_len = ml_get_len(lnum);
if (line_len <= leader1_len) {
return false;
}
@@ -647,7 +646,7 @@ void auto_format(bool trailblank, bool prev_line)
// in 'formatoptions' and there is a single character before the cursor.
// Otherwise the line would be broken and when typing another non-white
// next they are not joined back together.
int wasatend = (pos.col == (colnr_T)strlen(old));
bool wasatend = (pos.col == get_cursor_line_len());
if (*old != NUL && !trailblank && wasatend) {
dec_cursor();
int cc = gchar_cursor();
@@ -701,7 +700,7 @@ void auto_format(bool trailblank, bool prev_line)
// formatted.
if (!wasatend && has_format_option(FO_WHITE_PAR)) {
char *linep = get_cursor_line_ptr();
colnr_T len = (colnr_T)strlen(linep);
colnr_T len = get_cursor_line_len();
if (curwin->w_cursor.col == len) {
char *plinep = xstrnsave(linep, (size_t)len + 2);
plinep[len] = ' ';
@@ -1119,7 +1118,7 @@ void format_lines(linenr_T line_count, bool avoid_fex)
}
first_par_line = false;
// If the line is getting long, format it next time
if (strlen(get_cursor_line_ptr()) > (size_t)max_len) {
if (get_cursor_line_len() > max_len) {
force_format = true;
} else {
force_format = false;

2
src/nvim/textobject.c
View File

@@ -218,7 +218,7 @@ bool findpar(bool *pincl, int dir, int count, int what, bool both)
// Put the cursor on the last character in the last line and make the
// motion inclusive.
if ((curwin->w_cursor.col = (colnr_T)strlen(line)) != 0) {
if ((curwin->w_cursor.col = ml_get_len(curr)) != 0) {
curwin->w_cursor.col--;
curwin->w_cursor.col -= utf_head_off(line, line + curwin->w_cursor.col);
*pincl = true;