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

Remove all occurences of the mb_ptr2char macro

Browse Source 
First step towards implemening issue #7401.

The same can be done for all deprecated mb_ functions in follow-up
patches.
This commit is contained in:
ZviRackover 2018-06-29 22:31:20 +03:00
parent 1593ee7cf2
commit 10b6afd652
24 changed files with 89 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/nvim/buffer.c
View File

@ -3223,7 +3223,7 @@ int build_stl_str_hl(
if (wp->w_cursor.col > (colnr_T)STRLEN(line_ptr))
byteval = 0;
else
byteval = (*mb_ptr2char)(line_ptr + wp->w_cursor.col);
byteval = utf_ptr2char(line_ptr + wp->w_cursor.col);
int groupdepth = 0;

2
src/nvim/charset.c
View File

@ -1379,7 +1379,7 @@ void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor,
ptr = ml_get_buf(wp->w_buffer, pos->lnum, false);
if (pos->col < (colnr_T)STRLEN(ptr)) {
int c = (*mb_ptr2char)(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) {

2
src/nvim/cursor.c
View File

@ -477,7 +477,7 @@ bool leftcol_changed(void)
int gchar_cursor(void)
{
if (has_mbyte)
return (*mb_ptr2char)(get_cursor_pos_ptr());
return utf_ptr2char(get_cursor_pos_ptr());
return (int)*get_cursor_pos_ptr();
}

2
src/nvim/digraph.c
View File

@ -1536,7 +1536,7 @@ static int getexactdigraph(int char1, int char2, int meta_char)
to = string_convert(&vc, buf, &len);
if (to != NULL) {
retval = (*mb_ptr2char)(to);
retval = utf_ptr2char(to);
xfree(to);
}
(void)convert_setup(&vc, NULL, NULL);

12
src/nvim/edit.c
View File

@ -2312,8 +2312,8 @@ static void ins_compl_longest_match(compl_T *match)
s = match->cp_str;
while (*p != NUL) {
if (has_mbyte) {
c1 = mb_ptr2char(p);
c2 = mb_ptr2char(s);
c1 = utf_ptr2char(p);
c2 = utf_ptr2char(s);
} else {
c1 = *p;
c2 = *s;
@ -6199,8 +6199,8 @@ int oneright(void)
/* Adjust for multi-wide char (excluding TAB) */
ptr = get_cursor_pos_ptr();
coladvance(getviscol() + ((*ptr != TAB && vim_isprintc(
(*mb_ptr2char)(ptr)
))
utf_ptr2char(ptr)
))
? ptr2cells(ptr) : 1));
curwin->w_set_curswant = TRUE;
/* Return OK if the cursor moved, FAIL otherwise (at window edge). */
@ -6259,7 +6259,7 @@ int oneleft(void)
/* Adjust for multi-wide char (not a TAB) */
ptr = get_cursor_pos_ptr();
if (*ptr != TAB && vim_isprintc(
(*mb_ptr2char)(ptr)
utf_ptr2char(ptr)
) && ptr2cells(ptr) > 1)
curwin->w_cursor.coladd = 0;
}
@ -8496,7 +8496,7 @@ int ins_copychar(linenr_T lnum)
if ((colnr_T)temp > curwin->w_virtcol)
ptr = prev_ptr;
c = (*mb_ptr2char)(ptr);
c = utf_ptr2char(ptr);
if (c == NUL) {
vim_beep(BO_COPY);
}

2
src/nvim/eval.c
View File

@ -15896,7 +15896,7 @@ static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
while (charidx >= 0 && byteidx < len) {
if (charidx == 0) {
rettv->vval.v_number = mb_ptr2char((const char_u *)str + byteidx);
rettv->vval.v_number = utf_ptr2char((const char_u *)str + byteidx);
break;
}
charidx--;

2
src/nvim/ex_cmds.c
View File

@ -5641,7 +5641,7 @@ void ex_sign(exarg_T *eap)
// Count cells and check for non-printable chars
cells = 0;
for (s = arg; s < p; s += (*mb_ptr2len)(s)) {
if (!vim_isprintc((*mb_ptr2char)(s))) {
if (!vim_isprintc(utf_ptr2char(s))) {
break;
}
cells += (*mb_ptr2cells)(s);

4
src/nvim/ex_docmd.c
View File

@ -2900,7 +2900,7 @@ const char * set_one_cmd_context(
p = (const char *)xp->xp_pattern;
while (*p != NUL) {
if (has_mbyte) {
c = mb_ptr2char((const char_u *)p);
c = utf_ptr2char((const char_u *)p);
} else {
c = (uint8_t)(*p);
}
@ -2922,7 +2922,7 @@ const char * set_one_cmd_context(
len = 0; /* avoid getting stuck when space is in 'isfname' */
while (*p != NUL) {
if (has_mbyte) {
c = mb_ptr2char((const char_u *)p);
c = utf_ptr2char((const char_u *)p);
} else {
c = *p;
}

6
src/nvim/ex_getln.c
View File

@ -3329,7 +3329,7 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
for (w = ccline.cmdbuff + ccline.cmdpos; w > ccline.cmdbuff; ) {
if (has_mbyte) {
len = (*mb_head_off)(ccline.cmdbuff, w - 1) + 1;
if (!vim_iswordc(mb_ptr2char(w - len)))
if (!vim_iswordc(utf_ptr2char(w - len)))
break;
w -= len;
} else {
@ -3845,13 +3845,13 @@ ExpandOne (
for (len = 0; xp->xp_files[0][len]; len += mb_len) {
if (has_mbyte) {
mb_len = (* mb_ptr2len)(&xp->xp_files[0][len]);
c0 = (* mb_ptr2char)(&xp->xp_files[0][len]);
c0 = utf_ptr2char(&xp->xp_files[0][len]);
} else {
c0 = xp->xp_files[0][len];
}
for (i = 1; i < xp->xp_numfiles; ++i) {
if (has_mbyte) {
ci =(* mb_ptr2char)(&xp->xp_files[i][len]);
ci = utf_ptr2char(&xp->xp_files[i][len]);
} else {
ci = xp->xp_files[i][len];
}

2
src/nvim/fold.c
View File

@ -1767,7 +1767,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume,
int len;
if (has_mbyte && (len = (*mb_ptr2len)(p)) > 1) {
if (!vim_isprintc((*mb_ptr2char)(p)))
if (!vim_isprintc(utf_ptr2char(p)))
break;
p += len - 1;
} else if (*p == TAB)

4
src/nvim/getchar.c
View File

@ -701,7 +701,7 @@ static int read_redo(int init, int old_redo)
buf[i] = (char_u)c;
if (i == n - 1) { // last byte of a character
if (n != 1) {
c = (*mb_ptr2char)(buf);
c = utf_ptr2char(buf);
}
break;
}
@ -1486,7 +1486,7 @@ int vgetc(void)
}
}
no_mapping--;
c = (*mb_ptr2char)(buf);
c = utf_ptr2char(buf);
}
break;

2
src/nvim/macros.h
View File

@ -126,7 +126,7 @@
# define MB_CHARLEN(p) mb_charlen(p)
# define MB_CHAR2LEN(c) mb_char2len(c)
# define PTR2CHAR(p) mb_ptr2char(p)
# define PTR2CHAR(p) utf_ptr2char(p)
# define RESET_BINDING(wp) (wp)->w_p_scb = FALSE; (wp)->w_p_crb = FALSE

2
src/nvim/mark.c
View File

@ -1470,7 +1470,7 @@ void mark_mb_adjustpos(buf_T *buf, pos_T *lp)
// double-wide character.
if (lp->coladd == 1
&& p[lp->col] != TAB
&& vim_isprintc((*mb_ptr2char)(p + lp->col))
&& vim_isprintc(utf_ptr2char(p + lp->col))
&& ptr2cells(p + lp->col) > 1) {
lp->coladd = 0;
}

6
src/nvim/mbyte.c
View File

@ -674,7 +674,7 @@ int mb_ptr2char_adv(const char_u **const pp)
{
int c;
c = (*mb_ptr2char)(*pp);
c = utf_ptr2char(*pp);
*pp += (*mb_ptr2len)(*pp);
return c;
}
@ -687,7 +687,7 @@ int mb_cptr2char_adv(const char_u **pp)
{
int c;
c = (*mb_ptr2char)(*pp);
c = utf_ptr2char(*pp);
*pp += utf_ptr2len(*pp);
return c;
}
@ -1714,7 +1714,7 @@ void mb_check_adjust_col(void *win_)
// Reset `coladd` when the cursor would be on the right half of a
// double-wide character.
if (win->w_cursor.coladd == 1 && p[win->w_cursor.col] != TAB
&& vim_isprintc((*mb_ptr2char)(p + win->w_cursor.col))
&& vim_isprintc(utf_ptr2char(p + win->w_cursor.col))
&& ptr2cells(p + win->w_cursor.col) > 1) {
win->w_cursor.coladd = 0;
}

1
src/nvim/mbyte.h
View File

@ -54,7 +54,6 @@ enum { MAX_MCO = 6 };
#define mb_ptr2cells_len utf_ptr2cells_len
#define mb_char2cells utf_char2cells
#define mb_off2cells utf_off2cells
#define mb_ptr2char utf_ptr2char
#define mb_head_off utf_head_off
/// Flags for vimconv_T

8
src/nvim/message.c
View File

@ -1219,7 +1219,7 @@ int msg_outtrans_len_attr(char_u *msgstr, int len, int attr)
// Don't include composing chars after the end.
mb_l = utfc_ptr2len_len((char_u *)str, len + 1);
if (mb_l > 1) {
c = (*mb_ptr2char)((char_u *)str);
c = utf_ptr2char((char_u *)str);
if (vim_isprintc(c)) {
// Printable multi-byte char: count the cells.
retval += (*mb_ptr2cells)((char_u *)str);
@ -1480,7 +1480,7 @@ void msg_prt_line(char_u *s, int list)
col += (*mb_ptr2cells)(s);
char buf[MB_MAXBYTES + 1];
if (lcs_nbsp != NUL && list
&& (mb_ptr2char(s) == 160 || mb_ptr2char(s) == 0x202f)) {
&& (utf_ptr2char(s) == 160 || utf_ptr2char(s) == 0x202f)) {
mb_char2bytes(lcs_nbsp, (char_u *)buf);
buf[(*mb_ptr2len)((char_u *)buf)] = NUL;
} else {
@ -2868,7 +2868,7 @@ do_dialog (
retval = 1;
for (i = 0; hotkeys[i]; ++i) {
if (has_mbyte) {
if ((*mb_ptr2char)(hotkeys + i) == c)
if (utf_ptr2char(hotkeys + i) == c)
break;
i += (*mb_ptr2len)(hotkeys + i) - 1;
} else if (hotkeys[i] == c)
@ -2910,7 +2910,7 @@ copy_char (
if (has_mbyte) {
if (lowercase) {
c = mb_tolower((*mb_ptr2char)(from));
c = mb_tolower(utf_ptr2char(from));
return (*mb_char2bytes)(c, to);
} else {
len = (*mb_ptr2len)(from);

6
src/nvim/misc1.c
View File

@ -1512,7 +1512,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
&& msg_silent == 0
&& !ins_compl_active()
) {
showmatch(mb_ptr2char(buf));
showmatch(utf_ptr2char(buf));
}
if (!p_ri || (State & REPLACE_FLAG)) {
@ -1752,7 +1752,7 @@ int gchar_pos(pos_T *pos)
char_u *ptr = ml_get_pos(pos);
if (has_mbyte)
return (*mb_ptr2char)(ptr);
return utf_ptr2char(ptr);
return (int)*ptr;
}
@ -2393,7 +2393,7 @@ int get_keystroke(void)
if (MB_BYTE2LEN(n) > len)
continue; /* more bytes to get */
buf[len >= buflen ? buflen - 1 : len] = NUL;
n = (*mb_ptr2char)(buf);
n = utf_ptr2char(buf);
}
#ifdef UNIX
if (n == intr_char)

8
src/nvim/ops.c
View File

@ -3620,9 +3620,9 @@ int do_join(size_t count,
curr = skipwhite(curr);
if (*curr != ')' && currsize != 0 && endcurr1 != TAB
&& (!has_format_option(FO_MBYTE_JOIN)
|| (mb_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
|| (utf_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
&& (!has_format_option(FO_MBYTE_JOIN2)
|| mb_ptr2char(curr) < 0x100 || endcurr1 < 0x100)
|| utf_ptr2char(curr) < 0x100 || endcurr1 < 0x100)
) {
/* don't add a space if the line is ending in a space */
if (endcurr1 == ' ')
@ -3642,10 +3642,10 @@ int do_join(size_t count,
if (has_mbyte) {
cend = curr + currsize;
MB_PTR_BACK(curr, cend);
endcurr1 = (*mb_ptr2char)(cend);
endcurr1 = utf_ptr2char(cend);
if (cend > curr) {
MB_PTR_BACK(curr, cend);
endcurr2 = (*mb_ptr2char)(cend);
endcurr2 = utf_ptr2char(cend);
}
} else {
endcurr1 = *(curr + currsize - 1);

20
src/nvim/option.c
View File

@ -2703,7 +2703,7 @@ did_set_string_option (
if (*p != NUL)
x2 = *p++;
if (*p != NUL) {
x3 = mb_ptr2char(p);
x3 = utf_ptr2char(p);
p += mb_ptr2len(p);
}
if (x2 != ':' || x3 == -1 || (*p != NUL && *p != ',')) {
@ -6408,20 +6408,20 @@ static void langmap_set(void)
}
if (p[0] == '\\' && p[1] != NUL)
++p;
from = (*mb_ptr2char)(p);
from = utf_ptr2char(p);
to = NUL;
if (p2 == NULL) {
MB_PTR_ADV(p);
if (p[0] != ',') {
if (p[0] == '\\')
++p;
to = (*mb_ptr2char)(p);
to = utf_ptr2char(p);
}
} else {
if (p2[0] != ',') {
if (p2[0] == '\\')
++p2;
to = (*mb_ptr2char)(p2);
to = utf_ptr2char(p2);
}
}
if (to == NUL) {
@ -6853,26 +6853,26 @@ void find_mps_values(int *initc, int *findc, int *backwards, int switchit)
if (has_mbyte) {
char_u *prev;
if (mb_ptr2char(ptr) == *initc) {
if (utf_ptr2char(ptr) == *initc) {
if (switchit) {
*findc = *initc;
*initc = mb_ptr2char(ptr + mb_ptr2len(ptr) + 1);
*initc = utf_ptr2char(ptr + mb_ptr2len(ptr) + 1);
*backwards = TRUE;
} else {
*findc = mb_ptr2char(ptr + mb_ptr2len(ptr) + 1);
*findc = utf_ptr2char(ptr + mb_ptr2len(ptr) + 1);
*backwards = FALSE;
}
return;
}
prev = ptr;
ptr += mb_ptr2len(ptr) + 1;
if (mb_ptr2char(ptr) == *initc) {
if (utf_ptr2char(ptr) == *initc) {
if (switchit) {
*findc = *initc;
*initc = mb_ptr2char(prev);
*initc = utf_ptr2char(prev);
*backwards = FALSE;
} else {
*findc = mb_ptr2char(prev);
*findc = utf_ptr2char(prev);
*backwards = TRUE;
}
return;

26
src/nvim/regexp.c
View File

@ -776,7 +776,7 @@ static int get_equi_class(char_u **pp)
l = (*mb_ptr2len)(p + 2);
if (p[l + 2] == '=' && p[l + 3] == ']') {
if (has_mbyte)
c = mb_ptr2char(p + 2);
c = utf_ptr2char(p + 2);
else
c = p[2];
*pp += l + 4;
@ -1111,7 +1111,7 @@ static int get_coll_element(char_u **pp)
l = (*mb_ptr2len)(p + 2);
if (p[l + 2] == '.' && p[l + 3] == ']') {
if (has_mbyte)
c = mb_ptr2char(p + 2);
c = utf_ptr2char(p + 2);
else
c = p[2];
*pp += l + 4;
@ -1300,7 +1300,7 @@ static regprog_T *bt_regcomp(char_u *expr, int re_flags)
if (OP(scan) == EXACTLY) {
if (has_mbyte)
r->regstart = (*mb_ptr2char)(OPERAND(scan));
r->regstart = utf_ptr2char(OPERAND(scan));
else
r->regstart = *OPERAND(scan);
} else if (OP(scan) == BOW
@ -1311,7 +1311,7 @@ static regprog_T *bt_regcomp(char_u *expr, int re_flags)
char_u *regnext_scan = regnext(scan);
if (OP(regnext_scan) == EXACTLY) {
if (has_mbyte)
r->regstart = (*mb_ptr2char)(OPERAND(regnext_scan));
r->regstart = utf_ptr2char(OPERAND(regnext_scan));
else
r->regstart = *OPERAND(regnext_scan);
}
@ -2417,7 +2417,7 @@ collection:
/* produce a multibyte character, including any
* following composing characters */
startc = mb_ptr2char(regparse);
startc = utf_ptr2char(regparse);
len = (*mb_ptr2len)(regparse);
if (enc_utf8 && utf_char2len(startc) != len)
startc = -1; /* composing chars */
@ -2907,7 +2907,7 @@ static int peekchr(void)
* Then backslashing it won't do anything.
*/
if (has_mbyte)
curchr = (*mb_ptr2char)(regparse + 1);
curchr = utf_ptr2char(regparse + 1);
else
curchr = c;
}
@ -2916,7 +2916,7 @@ static int peekchr(void)
default:
if (has_mbyte)
curchr = (*mb_ptr2char)(regparse);
curchr = utf_ptr2char(regparse);
}
return curchr;
@ -3469,7 +3469,7 @@ static long bt_regexec_both(char_u *line,
int c;
if (has_mbyte)
c = (*mb_ptr2char)(prog->regmust);
c = utf_ptr2char(prog->regmust);
else
c = *prog->regmust;
s = line + col;
@ -3505,7 +3505,7 @@ static long bt_regexec_both(char_u *line,
int c;
if (has_mbyte)
c = (*mb_ptr2char)(regline + col);
c = utf_ptr2char(regline + col);
else
c = regline[col];
if (prog->regstart == NUL
@ -3861,7 +3861,7 @@ regmatch (
if (WITH_NL(op))
op -= ADD_NL;
if (has_mbyte)
c = (*mb_ptr2char)(reginput);
c = utf_ptr2char(reginput);
else
c = *reginput;
switch (op) {
@ -5474,7 +5474,7 @@ do_class:
} else if (rex.reg_line_lbr && *scan == '\n' && WITH_NL(OP(p))) {
scan++;
} else if (has_mbyte && (len = (*mb_ptr2len)(scan)) > 1) {
if ((cstrchr(opnd, (*mb_ptr2char)(scan)) == NULL) == testval) {
if ((cstrchr(opnd, utf_ptr2char(scan)) == NULL) == testval) {
break;
}
scan += len;
@ -6783,7 +6783,7 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
c = *src++;
}
} else if (has_mbyte)
c = mb_ptr2char(src - 1);
c = utf_ptr2char(src - 1);
/* Write to buffer, if copy is set. */
if (func_one != (fptr_T)NULL)
@ -6879,7 +6879,7 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
dst += 2;
} else {
if (has_mbyte)
c = mb_ptr2char(s);
c = utf_ptr2char(s);
else
c = *s;

4
src/nvim/regexp_nfa.c
View File

@ -5034,7 +5034,7 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
int clen;
if (has_mbyte) {
curc = (*mb_ptr2char)(reginput);
curc = utf_ptr2char(reginput);
clen = (*mb_ptr2len)(reginput);
} else {
curc = *reginput;
@ -5501,7 +5501,7 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
// We don't care about the order of composing characters.
// Get them into cchars[] first.
while (len < clen) {
mc = mb_ptr2char(reginput + len);
mc = utf_ptr2char(reginput + len);
cchars[ccount++] = mc;
len += mb_char2len(mc);
if (ccount == MAX_MCO)

52
src/nvim/spell.c
View File

@ -1956,7 +1956,7 @@ static int count_syllables(slang_T *slang, char_u *word)
skip = false;
} else {
// No recognized syllable item, at least a syllable char then?
c = mb_ptr2char(p);
c = utf_ptr2char(p);
len = (*mb_ptr2len)(p);
if (vim_strchr(slang->sl_syllable, c) == NULL)
skip = false; // No, search for next syllable
@ -2271,7 +2271,7 @@ static void use_midword(slang_T *lp, win_T *wp)
int c, l, n;
char_u *bp;
c = mb_ptr2char(p);
c = utf_ptr2char(p);
l = (*mb_ptr2len)(p);
if (c < 256 && l <= 2)
wp->w_s->b_spell_ismw[c] = true;
@ -2597,14 +2597,14 @@ static bool spell_iswordp(char_u *p, win_T *wp)
if (wp->w_s->b_spell_ismw[*p])
s = p + 1; // skip a mid-word character
} else {
c = mb_ptr2char(p);
c = utf_ptr2char(p);
if (c < 256 ? wp->w_s->b_spell_ismw[c]
: (wp->w_s->b_spell_ismw_mb != NULL
&& vim_strchr(wp->w_s->b_spell_ismw_mb, c) != NULL))
s = p + l;
}
c = mb_ptr2char(s);
c = utf_ptr2char(s);
if (c > 255)
return spell_mb_isword_class(mb_get_class(s), wp);
return spelltab.st_isw[c];
@ -2620,7 +2620,7 @@ bool spell_iswordp_nmw(const char_u *p, win_T *wp)
int c;
if (has_mbyte) {
c = mb_ptr2char(p);
c = utf_ptr2char(p);
if (c > 255) {
return spell_mb_isword_class(mb_get_class(p), wp);
}
@ -4303,10 +4303,10 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
} else if (!soundfold
&& slang->sl_has_map
&& similar_chars(slang,
mb_ptr2char(tword
utf_ptr2char(tword
+ sp->ts_twordlen
- sp->ts_tcharlen),
mb_ptr2char(fword
utf_ptr2char(fword
+ sp->ts_fcharstart))) {
// For a similar character adjust score from
// SCORE_SUBST to SCORE_SIMILAR.
@ -4315,7 +4315,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
} else if (sp->ts_isdiff == DIFF_INSERT
&& sp->ts_twordlen > sp->ts_tcharlen) {
p = tword + sp->ts_twordlen - sp->ts_tcharlen;
c = mb_ptr2char(p);
c = utf_ptr2char(p);
if (enc_utf8 && utf_iscomposing(c)) {
// Inserting a composing char doesn't
// count that much.
@ -4327,7 +4327,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
// tree (might seem illogical but does
// give better scores).
MB_PTR_BACK(tword, p);
if (c == mb_ptr2char(p)) {
if (c == utf_ptr2char(p)) {
sp->ts_score -= SCORE_INS - SCORE_INSDUP;
}
}
@ -4389,11 +4389,11 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
// a bit illogical for soundfold tree but it does give better
// results.
if (has_mbyte) {
c = mb_ptr2char(fword + sp->ts_fidx);
c = utf_ptr2char(fword + sp->ts_fidx);
stack[depth].ts_fidx += MB_PTR2LEN(fword + sp->ts_fidx);
if (enc_utf8 && utf_iscomposing(c)) {
stack[depth].ts_score -= SCORE_DEL - SCORE_DELCOMP;
} else if (c == mb_ptr2char(fword + stack[depth].ts_fidx)) {
} else if (c == utf_ptr2char(fword + stack[depth].ts_fidx)) {
stack[depth].ts_score -= SCORE_DEL - SCORE_DELDUP;
}
} else {
@ -4517,13 +4517,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
if (has_mbyte) {
n = MB_CPTR2LEN(p);
c = mb_ptr2char(p);
c = utf_ptr2char(p);
if (p[n] == NUL)
c2 = NUL;
else if (!soundfold && !spell_iswordp(p + n, curwin))
c2 = c; // don't swap non-word char
else
c2 = mb_ptr2char(p + n);
c2 = utf_ptr2char(p + n);
} else {
if (p[1] == NUL)
c2 = NUL;
@ -4578,7 +4578,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
p = fword + sp->ts_fidx;
if (has_mbyte) {
n = MB_PTR2LEN(p);
c = mb_ptr2char(p + n);
c = utf_ptr2char(p + n);
memmove(p + MB_PTR2LEN(p + n), p, n);
mb_char2bytes(c, p);
} else {
@ -4594,13 +4594,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
p = fword + sp->ts_fidx;
if (has_mbyte) {
n = MB_CPTR2LEN(p);
c = mb_ptr2char(p);
c = utf_ptr2char(p);
fl = MB_CPTR2LEN(p + n);
c2 = mb_ptr2char(p + n);
c2 = utf_ptr2char(p + n);
if (!soundfold && !spell_iswordp(p + n + fl, curwin))
c3 = c; // don't swap non-word char
else
c3 = mb_ptr2char(p + n + fl);
c3 = utf_ptr2char(p + n + fl);
} else {
c = *p;
c2 = p[1];
@ -4653,9 +4653,9 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
p = fword + sp->ts_fidx;
if (has_mbyte) {
n = MB_PTR2LEN(p);
c2 = mb_ptr2char(p + n);
c2 = utf_ptr2char(p + n);
fl = MB_PTR2LEN(p + n);
c = mb_ptr2char(p + n + fl);
c = utf_ptr2char(p + n + fl);
tl = MB_PTR2LEN(p + n + fl);
memmove(p + fl + tl, p, n);
mb_char2bytes(c, p);
@ -4692,7 +4692,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
p = fword + sp->ts_fidx;
if (has_mbyte) {
n = MB_CPTR2LEN(p);
c = mb_ptr2char(p);
c = utf_ptr2char(p);
fl = MB_CPTR2LEN(p + n);
fl += MB_CPTR2LEN(p + n + fl);
memmove(p, p + n, fl);
@ -4717,7 +4717,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
if (has_mbyte) {
n = MB_PTR2LEN(p);
n += MB_PTR2LEN(p + n);
c = mb_ptr2char(p + n);
c = utf_ptr2char(p + n);
tl = MB_PTR2LEN(p + n);
memmove(p + tl, p, n);
mb_char2bytes(c, p);
@ -4745,7 +4745,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
if (has_mbyte) {
n = MB_CPTR2LEN(p);
n += MB_CPTR2LEN(p + n);
c = mb_ptr2char(p + n);
c = utf_ptr2char(p + n);
tl = MB_CPTR2LEN(p + n);
memmove(p + tl, p, n);
mb_char2bytes(c, p);
@ -4767,7 +4767,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
// Undo ROT3R: "312" -> "123"
p = fword + sp->ts_fidx;
if (has_mbyte) {
c = mb_ptr2char(p);
c = utf_ptr2char(p);
tl = MB_PTR2LEN(p);
n = MB_PTR2LEN(p + tl);
n += MB_PTR2LEN(p + tl + n);
@ -5607,7 +5607,7 @@ static bool similar_chars(slang_T *slang, int c1, int c2)
if (HASHITEM_EMPTY(hi))
m1 = 0;
else
m1 = mb_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
m1 = utf_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
} else
m1 = slang->sl_map_array[c1];
if (m1 == 0)
@ -5620,7 +5620,7 @@ static bool similar_chars(slang_T *slang, int c1, int c2)
if (HASHITEM_EMPTY(hi))
m2 = 0;
else
m2 = mb_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
m2 = utf_ptr2char(hi->hi_key + STRLEN(hi->hi_key) + 1);
} else
m2 = slang->sl_map_array[c2];
@ -5660,7 +5660,7 @@ add_suggestion (
MB_PTR_BACK(goodword, pgood);
MB_PTR_BACK(su->su_badptr, pbad);
if (has_mbyte) {
if (mb_ptr2char(pgood) != mb_ptr2char(pbad))
if (utf_ptr2char(pgood) != utf_ptr2char(pbad))
break;
} else if (*pgood != *pbad)
break;

2
src/nvim/syntax.c
View File

@ -4103,7 +4103,7 @@ get_syn_options(
} else if (flagtab[fidx].argtype == 11 && arg[5] == '=') {
/* cchar=? */
if (has_mbyte) {
*conceal_char = mb_ptr2char(arg + 6);
*conceal_char = utf_ptr2char(arg + 6);
arg += mb_ptr2len(arg + 6) - 1;
} else {
*conceal_char = arg[6];

2
src/nvim/window.c
View File

@ -5609,7 +5609,7 @@ int match_add(win_T *wp, const char *const grp, const char *const pat,
m->match.rmm_maxcol = 0;
m->conceal_char = 0;
if (conceal_char != NULL) {
m->conceal_char = (*mb_ptr2char)((const char_u *)conceal_char);
m->conceal_char = utf_ptr2char((const char_u *)conceal_char);
}
// Set up position matches