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

refactor: use "csarg" for CharsizeArg variables (#27123)

Browse Source
This commit is contained in:
zeertzjq 2024-01-22 10:39:37 +08:00 committed by GitHub
parent 8c6de9147c
commit e68decab03
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 132 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/nvim/cursor.c
View File

@ -141,12 +141,12 @@ static int coladvance2(pos_T *pos, bool addspaces, bool finetune, colnr_T wcol_a
}
}
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, pos->lnum, line);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, pos->lnum, line);
StrCharInfo ci = utf_ptr2StrCharInfo(line);
col = 0;
while (col <= wcol && *ci.ptr != NUL) {
CharSize cs = win_charsize(cstype, col, ci.ptr, ci.chr.value, &arg);
CharSize cs = win_charsize(cstype, col, ci.ptr, ci.chr.value, &csarg);
csize = cs.width;
head = cs.head;
col += cs.width;

14
src/nvim/drawline.c
View File

@ -1338,13 +1338,13 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, s
char *prev_ptr = ptr;
CharSize cs = { 0 };
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, wp, lnum, line);
arg.max_head_vcol = start_col;
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, wp, lnum, line);
csarg.max_head_vcol = start_col;
int vcol = wlv.vcol;
StrCharInfo ci = utf_ptr2StrCharInfo(ptr);
while (vcol < start_col && *ci.ptr != NUL) {
cs = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg);
cs = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg);
vcol += cs.width;
prev_ptr = ci.ptr;
ci = utfc_next(ci);
@ -2083,11 +2083,11 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, s
int mb_off = utf_head_off(line, ptr - 1);
char *p = ptr - (mb_off + 1);
CharsizeArg arg;
CharsizeArg csarg;
// lnum == 0, do not want virtual text to be counted here
CSType cstype = init_charsize_arg(&arg, wp, 0, line);
CSType cstype = init_charsize_arg(&csarg, wp, 0, line);
wlv.n_extra = win_charsize(cstype, wlv.vcol, p, utf_ptr2CharInfo(p).value,
&arg).width - 1;
&csarg).width - 1;
if (on_last_col && mb_c != TAB) {
// Do not continue search/match highlighting over the

22
src/nvim/edit.c
View File

@ -1687,11 +1687,11 @@ void change_indent(int type, int amount, int round, int replaced, bool call_chan
char *const line = get_cursor_line_ptr();
vcol = 0;
if (*line != NUL) {
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, 0, line);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, 0, line);
StrCharInfo ci = utf_ptr2StrCharInfo(line);
while (true) {
int next_vcol = vcol + win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg).width;
int next_vcol = vcol + win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
if (next_vcol > end_vcol) {
break;
}
@ -4353,13 +4353,13 @@ static bool ins_tab(void)
char *tab = "\t";
int32_t tab_v = (uint8_t)(*tab);
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, 0, tab);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, 0, tab);
// Use as many TABs as possible. Beware of 'breakindent', 'showbreak'
// and 'linebreak' adding extra virtual columns.
while (ascii_iswhite(*ptr)) {
int i = win_charsize(cstype, vcol, tab, tab_v, &arg).width;
int i = win_charsize(cstype, vcol, tab, tab_v, &csarg).width;
if (vcol + i > want_vcol) {
break;
}
@ -4381,9 +4381,9 @@ static bool ins_tab(void)
if (change_col >= 0) {
int repl_off = 0;
// Skip over the spaces we need.
cstype = init_charsize_arg(&arg, curwin, 0, ptr);
cstype = init_charsize_arg(&csarg, curwin, 0, ptr);
while (vcol < want_vcol && *ptr == ' ') {
vcol += win_charsize(cstype, vcol, ptr, (uint8_t)(' '), &arg).width;
vcol += win_charsize(cstype, vcol, ptr, (uint8_t)(' '), &csarg).width;
ptr++;
repl_off++;
}
@ -4567,12 +4567,12 @@ int ins_copychar(linenr_T lnum)
int const end_vcol = curwin->w_virtcol;
char *line = ml_get(lnum);
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, lnum, line);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, lnum, line);
StrCharInfo ci = utf_ptr2StrCharInfo(line);
int vcol = 0;
while (vcol < end_vcol && *ci.ptr != NUL) {
vcol += win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg).width;
vcol += win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
if (vcol > end_vcol) {
break;
}

6
src/nvim/getchar.c
View File

@ -2507,15 +2507,15 @@ static int vgetorpeek(bool advance)
ptr = get_cursor_line_ptr();
char *endptr = ptr + curwin->w_cursor.col;
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, curwin->w_cursor.lnum, ptr);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, curwin->w_cursor.lnum, ptr);
StrCharInfo ci = utf_ptr2StrCharInfo(ptr);
int vcol = 0;
while (ci.ptr < endptr) {
if (!ascii_iswhite(ci.chr.value)) {
curwin->w_wcol = vcol;
}
vcol += win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg).width;
vcol += win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
ci = utfc_next(ci);
}

14
src/nvim/indent.c
View File

@ -1248,13 +1248,13 @@ int get_lisp_indent(void)
char *line = get_cursor_line_ptr();
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, pos->lnum, line);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, pos->lnum, line);
StrCharInfo sci = utf_ptr2StrCharInfo(line);
amount = 0;
while (*sci.ptr != NUL && col > 0) {
amount += win_charsize(cstype, amount, sci.ptr, sci.chr.value, &arg).width;
amount += win_charsize(cstype, amount, sci.ptr, sci.chr.value, &csarg).width;
sci = utfc_next(sci);
col--;
}
@ -1274,7 +1274,7 @@ int get_lisp_indent(void)
colnr_T firsttry = amount;
while (ascii_iswhite(*that)) {
amount += win_charsize(cstype, amount, that, (uint8_t)(*that), &arg).width;
amount += win_charsize(cstype, amount, that, (uint8_t)(*that), &csarg).width;
that++;
}
@ -1303,13 +1303,13 @@ int get_lisp_indent(void)
parencount--;
}
if ((ci.value == '\\') && (*(that + 1) != NUL)) {
amount += win_charsize(cstype, amount, that, ci.value, &arg).width;
amount += win_charsize(cstype, amount, that, ci.value, &csarg).width;
StrCharInfo next_sci = utfc_next((StrCharInfo){ that, ci });
that = next_sci.ptr;
ci = next_sci.chr;
}
amount += win_charsize(cstype, amount, that, ci.value, &arg).width;
amount += win_charsize(cstype, amount, that, ci.value, &csarg).width;
StrCharInfo next_sci = utfc_next((StrCharInfo){ that, ci });
that = next_sci.ptr;
ci = next_sci.chr;
@ -1317,7 +1317,7 @@ int get_lisp_indent(void)
}
while (ascii_iswhite(*that)) {
amount += win_charsize(cstype, amount, that, (uint8_t)(*that), &arg).width;
amount += win_charsize(cstype, amount, that, (uint8_t)(*that), &csarg).width;
that++;
}

6
src/nvim/mouse.c
View File

@ -1755,12 +1755,12 @@ colnr_T vcol2col(win_T *wp, linenr_T lnum, colnr_T vcol, colnr_T *coladdp)
{
// try to advance to the specified column
char *line = ml_get_buf(wp->w_buffer, lnum);
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, wp, lnum, line);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, wp, lnum, line);
StrCharInfo ci = utf_ptr2StrCharInfo(line);
int cur_vcol = 0;
while (cur_vcol < vcol && *ci.ptr != NUL) {
int next_vcol = cur_vcol + win_charsize(cstype, cur_vcol, ci.ptr, ci.chr.value, &arg).width;
int next_vcol = cur_vcol + win_charsize(cstype, cur_vcol, ci.ptr, ci.chr.value, &csarg).width;
if (next_vcol > vcol) {
break;
}

36
src/nvim/ops.c
View File

@ -387,12 +387,12 @@ static void shift_block(oparg_T *oap, int amount)
}
// TODO(vim): is passing bd.textstart for start of the line OK?
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, curwin->w_cursor.lnum, bd.textstart);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, curwin->w_cursor.lnum, bd.textstart);
StrCharInfo ci = utf_ptr2StrCharInfo(bd.textstart);
int vcol = bd.start_vcol;
while (ascii_iswhite(ci.chr.value)) {
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg).width;
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
ci = utfc_next(ci);
total += incr;
vcol += incr;
@ -449,10 +449,10 @@ static void shift_block(oparg_T *oap, int amount)
// The character's column is in "bd.start_vcol".
colnr_T non_white_col = bd.start_vcol;
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, curwin->w_cursor.lnum, bd.textstart);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, curwin->w_cursor.lnum, bd.textstart);
while (ascii_iswhite(*non_white)) {
incr = win_charsize(cstype, non_white_col, non_white, (uint8_t)(*non_white), &arg).width;
incr = win_charsize(cstype, non_white_col, non_white, (uint8_t)(*non_white), &csarg).width;
non_white_col += incr;
non_white++;
}
@ -476,10 +476,10 @@ static void shift_block(oparg_T *oap, int amount)
if (bd.startspaces) {
verbatim_copy_width -= bd.start_char_vcols;
}
cstype = init_charsize_arg(&arg, curwin, 0, bd.textstart);
cstype = init_charsize_arg(&csarg, curwin, 0, bd.textstart);
StrCharInfo ci = utf_ptr2StrCharInfo(verbatim_copy_end);
while (verbatim_copy_width < destination_col) {
incr = win_charsize(cstype, verbatim_copy_width, ci.ptr, ci.chr.value, &arg).width;
incr = win_charsize(cstype, verbatim_copy_width, ci.ptr, ci.chr.value, &csarg).width;
if (verbatim_copy_width + incr > destination_col) {
break;
}
@ -3247,12 +3247,12 @@ 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();
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, curwin->w_cursor.lnum, oldp);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, curwin->w_cursor.lnum, oldp);
StrCharInfo ci = utf_ptr2StrCharInfo(oldp);
vcol = 0;
while (vcol < col && *ci.ptr != NUL) {
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg).width;
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
vcol += incr;
ci = utfc_next(ci);
}
@ -3285,10 +3285,10 @@ void do_put(int regname, yankreg_T *reg, int dir, int count, int flags)
// calculate number of spaces required to fill right side of block
spaces = y_width + 1;
cstype = init_charsize_arg(&arg, curwin, 0, y_array[i]);
cstype = init_charsize_arg(&csarg, curwin, 0, y_array[i]);
ci = utf_ptr2StrCharInfo(y_array[i]);
while (*ci.ptr != NUL) {
spaces -= win_charsize(cstype, 0, ci.ptr, ci.chr.value, &arg).width;
spaces -= win_charsize(cstype, 0, ci.ptr, ci.chr.value, &csarg).width;
ci = utfc_next(ci);
}
if (spaces < 0) {
@ -4223,12 +4223,12 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
char *line = ml_get(lnum);
char *prev_pstart = line;
CharsizeArg arg;
CSType cstype = init_charsize_arg(&arg, curwin, lnum, line);
CharsizeArg csarg;
CSType cstype = init_charsize_arg(&csarg, curwin, lnum, line);
StrCharInfo ci = utf_ptr2StrCharInfo(line);
int vcol = bdp->start_vcol;
while (vcol < oap->start_vcol && *ci.ptr != NUL) {
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg).width;
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
vcol += incr;
if (ascii_iswhite(ci.chr.value)) {
bdp->pre_whitesp += incr;
@ -4278,13 +4278,13 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
}
}
} else {
cstype = init_charsize_arg(&arg, curwin, lnum, line);
cstype = init_charsize_arg(&csarg, curwin, lnum, line);
ci = utf_ptr2StrCharInfo(pend);
vcol = bdp->end_vcol;
char *prev_pend = pend;
while (vcol <= oap->end_vcol && *ci.ptr != NUL) {
prev_pend = ci.ptr;
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &arg).width;
incr = win_charsize(cstype, vcol, ci.ptr, ci.chr.value, &csarg).width;
vcol += incr;
ci = utfc_next(ci);
}

142
src/nvim/plines.c
View File

@ -59,12 +59,12 @@ int win_chartabsize(win_T *wp, char *p, colnr_T col)
/// @return Number of characters the string will take on the screen.
int linetabsize_col(int startvcol, char *s)
{
CharsizeArg arg;
CSType const cstype = init_charsize_arg(&arg, curwin, 0, s);
CharsizeArg csarg;
CSType const cstype = init_charsize_arg(&csarg, curwin, 0, s);
if (cstype == kCharsizeFast) {
return linesize_fast(&arg, startvcol, MAXCOL);
return linesize_fast(&csarg, startvcol, MAXCOL);
} else {
return linesize_regular(&arg, startvcol, MAXCOL);
return linesize_regular(&csarg, startvcol, MAXCOL);
}
}
@ -79,26 +79,26 @@ int linetabsize(win_T *wp, linenr_T lnum)
///
/// "line" is the start of the line.
/// When "lnum" is zero do not use inline virtual text.
CSType init_charsize_arg(CharsizeArg *cts, win_T *wp, linenr_T lnum, char *line)
CSType init_charsize_arg(CharsizeArg *csarg, win_T *wp, linenr_T lnum, char *line)
{
cts->win = wp;
cts->line = line;
cts->max_head_vcol = 0;
cts->cur_text_width_left = 0;
cts->cur_text_width_right = 0;
cts->virt_row = -1;
cts->indent_width = INT_MIN;
cts->use_tabstop = !wp->w_p_list || wp->w_p_lcs_chars.tab1;
csarg->win = wp;
csarg->line = line;
csarg->max_head_vcol = 0;
csarg->cur_text_width_left = 0;
csarg->cur_text_width_right = 0;
csarg->virt_row = -1;
csarg->indent_width = INT_MIN;
csarg->use_tabstop = !wp->w_p_list || wp->w_p_lcs_chars.tab1;
if (lnum > 0 && wp->w_buffer->b_virt_text_inline > 0) {
marktree_itr_get(wp->w_buffer->b_marktree, lnum - 1, 0, cts->iter);
MTKey mark = marktree_itr_current(cts->iter);
marktree_itr_get(wp->w_buffer->b_marktree, lnum - 1, 0, csarg->iter);
MTKey mark = marktree_itr_current(csarg->iter);
if (mark.pos.row == lnum - 1) {
cts->virt_row = lnum - 1;
csarg->virt_row = lnum - 1;
}
}
if (cts->virt_row >= 0
if (csarg->virt_row >= 0
|| (wp->w_p_wrap && (wp->w_p_lbr || wp->w_p_bri || *get_showbreak_value(wp) != NUL))) {
return kCharsizeRegular;
} else {
@ -115,16 +115,16 @@ CSType init_charsize_arg(CharsizeArg *cts, win_T *wp, linenr_T lnum, char *line)
/// of 'showbreak'/'breakindent' before "cts->max_head_vcol".
/// When "cts->max_head_vcol" is negative, only count in "head" the size
/// of 'showbreak'/'breakindent' before where cursor should be placed.
CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
CharSize charsize_regular(CharsizeArg *csarg, char *const cur, colnr_T const vcol,
int32_t const cur_char)
{
cts->cur_text_width_left = 0;
cts->cur_text_width_right = 0;
csarg->cur_text_width_left = 0;
csarg->cur_text_width_right = 0;
win_T *wp = cts->win;
win_T *wp = csarg->win;
buf_T *buf = wp->w_buffer;
char *line = cts->line;
bool const use_tabstop = cur_char == TAB && cts->use_tabstop;
char *line = csarg->line;
bool const use_tabstop = cur_char == TAB && csarg->use_tabstop;
int mb_added = 0;
bool has_lcs_eol = wp->w_p_list && wp->w_p_lcs_chars.eol != NUL;
@ -143,12 +143,12 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
is_doublewidth = size == 2 && cur_char > 0x80;
}
if (cts->virt_row >= 0) {
if (csarg->virt_row >= 0) {
int tab_size = size;
int col = (int)(cur - line);
while (true) {
MTKey mark = marktree_itr_current(cts->iter);
if (mark.pos.row != cts->virt_row || mark.pos.col > col) {
MTKey mark = marktree_itr_current(csarg->iter);
if (mark.pos.row != csarg->virt_row || mark.pos.col > col) {
break;
} else if (mark.pos.col == col) {
if (!mt_end(mark) && mark.flags & (MT_FLAG_DECOR_VIRT_TEXT_INLINE)) {
@ -157,9 +157,9 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
while (vt) {
if (!(vt->flags & kVTIsLines) && vt->pos == kVPosInline) {
if (mt_right(mark)) {
cts->cur_text_width_right += vt->width;
csarg->cur_text_width_right += vt->width;
} else {
cts->cur_text_width_left += vt->width;
csarg->cur_text_width_left += vt->width;
}
size += vt->width;
if (use_tabstop) {
@ -173,7 +173,7 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
}
}
}
marktree_itr_next(wp->w_buffer->b_marktree, cts->iter);
marktree_itr_next(wp->w_buffer->b_marktree, csarg->iter);
}
}
@ -193,7 +193,7 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
int col_off_prev = win_col_off(wp);
int width2 = wp->w_width_inner - col_off_prev + win_col_off2(wp);
colnr_T wcol = vcol + col_off_prev;
colnr_T max_head_vcol = cts->max_head_vcol;
colnr_T max_head_vcol = csarg->max_head_vcol;
int added = 0;
// cells taken by 'showbreak'/'breakindent' before current char
@ -204,7 +204,7 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
if (wcol >= width2 && width2 > 0) {
wcol %= width2;
}
head_prev = cts->indent_width;
head_prev = csarg->indent_width;
if (head_prev == INT_MIN) {
head_prev = 0;
if (*sbr != NUL) {
@ -213,7 +213,7 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
if (wp->w_p_bri) {
head_prev += get_breakindent_win(wp, line);
}
cts->indent_width = head_prev;
csarg->indent_width = head_prev;
}
if (wcol < head_prev) {
head_prev -= wcol;
@ -230,7 +230,7 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
if (wcol + size > wp->w_width) {
// cells taken by 'showbreak'/'breakindent' halfway current char
int head_mid = cts->indent_width;
int head_mid = csarg->indent_width;
if (head_mid == INT_MIN) {
head_mid = 0;
if (*sbr != NUL) {
@ -239,7 +239,7 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
if (wp->w_p_bri) {
head_mid += get_breakindent_win(wp, line);
}
cts->indent_width = head_mid;
csarg->indent_width = head_mid;
}
if (head_mid > 0 && wcol + size > wp->w_width_inner) {
// Calculate effective window width.
@ -259,7 +259,7 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
head += (max_head_vcol - (vcol + head_prev + prev_rem)
+ width2 - 1) / width2 * head_mid;
} else if (max_head_vcol < 0) {
int off = virt_text_cursor_off(cts, *cur == NUL);
int off = virt_text_cursor_off(csarg, *cur == NUL);
if (off >= prev_rem) {
if (size > off) {
head += (1 + (off - prev_rem) / width) * head_mid;
@ -279,11 +279,11 @@ CharSize charsize_regular(CharsizeArg *cts, char *const cur, colnr_T const vcol,
// If 'linebreak' set check at a blank before a non-blank if the line
// needs a break here
if (wp->w_p_lbr && wp->w_p_wrap && wp->w_width_inner != 0) {
char *t = cts->line;
char *t = csarg->line;
while (vim_isbreak((uint8_t)t[0])) {
t++;
}
vcol_start = (colnr_T)(t - cts->line);
vcol_start = (colnr_T)(t - csarg->line);
}
if (wp->w_p_lbr && vcol_start <= vcol
&& vim_isbreak((uint8_t)s[0])
@ -361,10 +361,10 @@ static inline CharSize charsize_fast_impl(win_T *const wp, bool use_tabstop, col
/// Like charsize_regular(), except it doesn't handle virtual text,
/// linebreak, breakindent and showbreak. Handles normal characters, tabs and wrapping.
/// Can be used if CSType is kCharsizeFast.
CharSize charsize_fast(CharsizeArg *cts, colnr_T const vcol, int32_t const cur_char)
CharSize charsize_fast(CharsizeArg *csarg, colnr_T const vcol, int32_t const cur_char)
FUNC_ATTR_PURE
{
return charsize_fast_impl(cts->win, cts->use_tabstop, vcol, cur_char);
return charsize_fast_impl(csarg->win, csarg->use_tabstop, vcol, cur_char);
}
/// Check that virtual column "vcol" is in the rightmost column of window "wp".
@ -403,20 +403,20 @@ static bool in_win_border(win_T *wp, colnr_T vcol)
///
/// @return virtual column before the character at 'len',
/// or full size of the line if 'len' is MAXCOL.
int linesize_regular(CharsizeArg *const arg, int vcol, colnr_T const len)
int linesize_regular(CharsizeArg *const csarg, int vcol, colnr_T const len)
{
char *const line = arg->line;
char *const line = csarg->line;
StrCharInfo ci = utf_ptr2StrCharInfo(line);
while (ci.ptr - line < len && *ci.ptr != NUL) {
vcol += charsize_regular(arg, ci.ptr, vcol, ci.chr.value).width;
vcol += charsize_regular(csarg, ci.ptr, vcol, ci.chr.value).width;
ci = utfc_next(ci);
}
// Check for inline virtual text after the end of the line.
if (len == MAXCOL && arg->virt_row >= 0) {
(void)charsize_regular(arg, ci.ptr, vcol, ci.chr.value);
vcol += arg->cur_text_width_left + arg->cur_text_width_right;
if (len == MAXCOL && csarg->virt_row >= 0) {
(void)charsize_regular(csarg, ci.ptr, vcol, ci.chr.value);
vcol += csarg->cur_text_width_left + csarg->cur_text_width_right;
}
return vcol;
@ -425,12 +425,12 @@ int linesize_regular(CharsizeArg *const arg, int vcol, colnr_T const len)
/// Like win_linesize_regular, but can be used when CStype is kCharsizeFast.
///
/// @see win_linesize_regular
int linesize_fast(CharsizeArg const *const arg, int vcol, colnr_T const len)
int linesize_fast(CharsizeArg const *const csarg, int vcol, colnr_T const len)
{
win_T *const wp = arg->win;
bool const use_tabstop = arg->use_tabstop;
win_T *const wp = csarg->win;
bool const use_tabstop = csarg->use_tabstop;
char *const line = arg->line;
char *const line = csarg->line;
StrCharInfo ci = utf_ptr2StrCharInfo(line);
while (ci.ptr - line < len && *ci.ptr != NUL) {
@ -443,15 +443,17 @@ int linesize_fast(CharsizeArg const *const arg, int vcol, colnr_T const len)
/// Get how many virtual columns inline virtual text should offset the cursor.
///
/// @param csarg should contain information stored by charsize_regular()
/// about widths of left and right gravity virtual text
/// @param on_NUL whether this is the end of the line
static int virt_text_cursor_off(CharsizeArg *cts, bool on_NUL)
static int virt_text_cursor_off(const CharsizeArg *csarg, bool on_NUL)
{
int off = 0;
if (!on_NUL || !(State & MODE_NORMAL)) {
off += cts->cur_text_width_left;
off += csarg->cur_text_width_left;
}
if (!on_NUL && (State & MODE_NORMAL)) {
off += cts->cur_text_width_right;
off += csarg->cur_text_width_right;
}
return off;
}
@ -473,16 +475,16 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
char *const line = ml_get_buf(wp->w_buffer, pos->lnum); // start of the line
int const end_col = pos->col;
CharsizeArg arg;
CharsizeArg csarg;
bool on_NUL = false;
CSType const cstype = init_charsize_arg(&arg, wp, pos->lnum, line);
arg.max_head_vcol = -1;
CSType const cstype = init_charsize_arg(&csarg, wp, pos->lnum, line);
csarg.max_head_vcol = -1;
colnr_T vcol = 0;
CharSize char_size;
StrCharInfo ci = utf_ptr2StrCharInfo(line);
if (cstype == kCharsizeFast) {
bool const use_tabstop = arg.use_tabstop;
bool const use_tabstop = csarg.use_tabstop;
while (true) {
if (*ci.ptr == NUL) {
// if cursor is at NUL, it is treated like 1 cell char
@ -499,10 +501,10 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
}
} else {
while (true) {
char_size = charsize_regular(&arg, ci.ptr, vcol, ci.chr.value);
char_size = charsize_regular(&csarg, ci.ptr, vcol, ci.chr.value);
if (*ci.ptr == NUL) {
// if cursor is at NUL, it is treated like 1 cell char unless there is virtual text
char_size.width = MAX(1, arg.cur_text_width_left + arg.cur_text_width_right);
char_size.width = MAX(1, csarg.cur_text_width_left + csarg.cur_text_width_right);
on_NUL = true;
break;
}
@ -535,7 +537,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
// cursor at end
*cursor = vcol + incr - 1;
} else {
vcol += virt_text_cursor_off(&arg, on_NUL);
vcol += virt_text_cursor_off(&csarg, on_NUL);
// cursor at start
*cursor = vcol + head;
}
@ -724,17 +726,17 @@ int plines_win_nofill(win_T *wp, linenr_T lnum, bool limit_winheight)
int plines_win_nofold(win_T *wp, linenr_T lnum)
{
char *s = ml_get_buf(wp->w_buffer, lnum);
CharsizeArg arg;
CSType const cstype = init_charsize_arg(&arg, wp, lnum, s);
if (*s == NUL && arg.virt_row < 0) {
CharsizeArg csarg;
CSType const cstype = init_charsize_arg(&csarg, wp, lnum, s);
if (*s == NUL && csarg.virt_row < 0) {
return 1; // be quick for an empty line
}
int64_t col;
if (cstype == kCharsizeFast) {
col = linesize_fast(&arg, 0, MAXCOL);
col = linesize_fast(&csarg, 0, MAXCOL);
} else {
col = linesize_regular(&arg, 0, MAXCOL);
col = linesize_regular(&csarg, 0, MAXCOL);
}
// If list mode is on, then the '$' at the end of the line may take up one
@ -774,20 +776,20 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
char *line = ml_get_buf(wp->w_buffer, lnum);
CharsizeArg cts;
CSType const cstype = init_charsize_arg(&cts, wp, lnum, line);
CharsizeArg csarg;
CSType const cstype = init_charsize_arg(&csarg, wp, lnum, line);
colnr_T vcol = 0;
StrCharInfo ci = utf_ptr2StrCharInfo(line);
if (cstype == kCharsizeFast) {
bool const use_tabstop = cts.use_tabstop;
bool const use_tabstop = csarg.use_tabstop;
while (*ci.ptr != NUL && --column >= 0) {
vcol += charsize_fast_impl(wp, use_tabstop, vcol, ci.chr.value).width;
ci = utfc_next(ci);
}
} else {
while (*ci.ptr != NUL && --column >= 0) {
vcol += charsize_regular(&cts, ci.ptr, vcol, ci.chr.value).width;
vcol += charsize_regular(&csarg, ci.ptr, vcol, ci.chr.value).width;
ci = utfc_next(ci);
}
}
@ -798,8 +800,8 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
// wraps from one screen line to the next (when 'columns' is not a multiple
// of 'ts') -- webb.
colnr_T col = vcol;
if (ci.chr.value == TAB && (State & MODE_NORMAL) && cts.use_tabstop) {
col += win_charsize(cstype, col, ci.ptr, ci.chr.value, &cts).width - 1;
if (ci.chr.value == TAB && (State & MODE_NORMAL) && csarg.use_tabstop) {
col += win_charsize(cstype, col, ci.ptr, ci.chr.value, &csarg).width - 1;
}
// Add column offset for 'number', 'relativenumber', 'foldcolumn', etc.

16
src/nvim/plines.h
View File

@ -42,7 +42,7 @@ typedef struct {
#endif
static inline CharSize win_charsize(CSType cstype, int vcol, char *ptr, int32_t chr,
CharsizeArg *arg)
CharsizeArg *csarg)
REAL_FATTR_NONNULL_ALL REAL_FATTR_WARN_UNUSED_RESULT REAL_FATTR_ALWAYS_INLINE;
/// Get the number of cells taken up on the screen by the given character at vcol.
@ -54,12 +54,12 @@ static inline CharSize win_charsize(CSType cstype, int vcol, char *ptr, int32_t
/// When "arg->max_head_vcol" is negative, only count in "head" the size
/// of 'showbreak'/'breakindent' before where cursor should be placed.
static inline CharSize win_charsize(CSType cstype, int vcol, char *ptr, int32_t chr,
CharsizeArg *arg)
CharsizeArg *csarg)
{
if (cstype == kCharsizeFast) {
return charsize_fast(arg, vcol, chr);
return charsize_fast(csarg, vcol, chr);
} else {
return charsize_regular(arg, ptr, vcol, chr);
return charsize_regular(csarg, ptr, vcol, chr);
}
}
@ -89,11 +89,11 @@ static inline int win_linetabsize(win_T *wp, linenr_T lnum, char *line, colnr_T
/// @return Number of characters the string will take on the screen.
static inline int win_linetabsize(win_T *wp, linenr_T lnum, char *line, colnr_T len)
{
CharsizeArg arg;
CSType const cstype = init_charsize_arg(&arg, wp, lnum, line);
CharsizeArg csarg;
CSType const cstype = init_charsize_arg(&csarg, wp, lnum, line);
if (cstype == kCharsizeFast) {
return linesize_fast(&arg, 0, len);
return linesize_fast(&csarg, 0, len);
} else {
return linesize_regular(&arg, 0, len);
return linesize_regular(&csarg, 0, len);
}
}