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 #8945 from ZviRackover/fix-7401-step5

Browse Source 
mbyte: remove mb_char2bytes
This commit is contained in:
Björn Linse 2018-09-11 09:03:09 +02:00 committed by GitHub
commit d6b3c09129
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 133 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/nvim/arabic.c
View File

@ -761,7 +761,7 @@ int arabic_shape(int c, int *ccp, int *c1p, int prev_c, int prev_c1,
char_u buf[MB_MAXBYTES + 1]; char_u buf[MB_MAXBYTES + 1];
// Update the first byte of the character // Update the first byte of the character
(*mb_char2bytes)(curr_c, buf); utf_char2bytes(curr_c, buf);
*ccp = buf[0]; *ccp = buf[0];
} }

2
src/nvim/digraph.c
View File

@ -1685,7 +1685,7 @@ static void printdigraph(digr_T *dp)
if (utf_iscomposing(dp->result)) { if (utf_iscomposing(dp->result)) {
*p++ = ' '; *p++ = ' ';
} }
p += (*mb_char2bytes)(dp->result, p); p += utf_char2bytes(dp->result, p);
*p = NUL; *p = NUL;
msg_outtrans_attr(buf, HL_ATTR(HLF_8)); msg_outtrans_attr(buf, HL_ATTR(HLF_8));

21
src/nvim/edit.c
View File

@ -2131,11 +2131,7 @@ int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int
char_u *p = IObuff; char_u *p = IObuff;
i = 0; i = 0;
while (i < actual_len && (p - IObuff + 6) < IOSIZE) { while (i < actual_len && (p - IObuff + 6) < IOSIZE) {
if (has_mbyte) { p += utf_char2bytes(wca[i++], p);
p += (*mb_char2bytes)(wca[i++], p);
} else {
*(p++) = wca[i++];
}
} }
*p = NUL; *p = NUL;
} }
@ -3084,10 +3080,10 @@ static void ins_compl_addleader(int c)
if (stop_arrow() == FAIL) { if (stop_arrow() == FAIL) {
return; return;
} }
if (has_mbyte && (cc = (*mb_char2len)(c)) > 1) { if ((cc = utf_char2len(c)) > 1) {
char_u buf[MB_MAXBYTES + 1]; char_u buf[MB_MAXBYTES + 1];
(*mb_char2bytes)(c, buf); utf_char2bytes(c, buf);
buf[cc] = NUL; buf[cc] = NUL;
ins_char_bytes(buf, cc); ins_char_bytes(buf, cc);
} else { } else {
@ -5334,10 +5330,10 @@ insertchar (
} else { } else {
int cc; int cc;
if (has_mbyte && (cc = (*mb_char2len)(c)) > 1) { if ((cc = utf_char2len(c)) > 1) {
char_u buf[MB_MAXBYTES + 1]; char_u buf[MB_MAXBYTES + 1];
(*mb_char2bytes)(c, buf); utf_char2bytes(c, buf);
buf[cc] = NUL; buf[cc] = NUL;
ins_char_bytes(buf, cc); ins_char_bytes(buf, cc);
AppendCharToRedobuff(c); AppendCharToRedobuff(c);
@ -8660,12 +8656,7 @@ static char_u *do_insert_char_pre(int c)
if (!has_event(EVENT_INSERTCHARPRE)) { if (!has_event(EVENT_INSERTCHARPRE)) {
return NULL; return NULL;
} }
if (has_mbyte) { buf[utf_char2bytes(c, (char_u *)buf)] = NUL;
buf[(*mb_char2bytes)(c, (char_u *) buf)] = NUL;
} else {
buf[0] = c;
buf[1] = NUL;
}
// Lock the text to avoid weird things from happening. // Lock the text to avoid weird things from happening.
textlock++; textlock++;

23
src/nvim/eval.c
View File

@ -4722,10 +4722,11 @@ static int get_string_tv(char_u **arg, typval_T *rettv, int evaluate)
++p; ++p;
/* For "\u" store the number according to /* For "\u" store the number according to
* 'encoding'. */ * 'encoding'. */
if (c != 'X') if (c != 'X') {
name += (*mb_char2bytes)(nr, name); name += utf_char2bytes(nr, name);
else } else {
*name++ = nr; *name++ = nr;
}
} }
break; break;
@ -9488,10 +9489,9 @@ static void f_getchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
temp[i++] = K_SPECIAL; temp[i++] = K_SPECIAL;
temp[i++] = K_SECOND(n); temp[i++] = K_SECOND(n);
temp[i++] = K_THIRD(n); temp[i++] = K_THIRD(n);
} else if (has_mbyte) } else {
i += (*mb_char2bytes)(n, temp + i); i += utf_char2bytes(n, temp + i);
else }
temp[i++] = n;
temp[i++] = NUL; temp[i++] = NUL;
rettv->v_type = VAR_STRING; rettv->v_type = VAR_STRING;
rettv->vval.v_string = vim_strsave(temp); rettv->vval.v_string = vim_strsave(temp);
@ -10021,7 +10021,7 @@ static void f_getmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
if (cur->conceal_char) { if (cur->conceal_char) {
char buf[MB_MAXBYTES + 1]; char buf[MB_MAXBYTES + 1];
buf[(*mb_char2bytes)((int)cur->conceal_char, (char_u *)buf)] = NUL; buf[utf_char2bytes((int)cur->conceal_char, (char_u *)buf)] = NUL;
tv_dict_add_str(dict, S_LEN("conceal"), buf); tv_dict_add_str(dict, S_LEN("conceal"), buf);
} }
@ -18361,12 +18361,7 @@ void set_vim_var_char(int c)
{ {
char buf[MB_MAXBYTES + 1]; char buf[MB_MAXBYTES + 1];
if (has_mbyte) { buf[utf_char2bytes(c, (char_u *)buf)] = NUL;
buf[(*mb_char2bytes)(c, (char_u *) buf)] = NUL;
} else {
buf[0] = c;
buf[1] = NUL;
}
set_vim_var_string(VV_CHAR, buf, -1); set_vim_var_string(VV_CHAR, buf, -1);
} }

34
src/nvim/ex_getln.c
View File

@ -1762,14 +1762,9 @@ static int command_line_handle_key(CommandLineState *s)
if (IS_SPECIAL(s->c) || mod_mask != 0) { if (IS_SPECIAL(s->c) || mod_mask != 0) {
put_on_cmdline(get_special_key_name(s->c, mod_mask), -1, true); put_on_cmdline(get_special_key_name(s->c, mod_mask), -1, true);
} else { } else {
if (has_mbyte) { s->j = utf_char2bytes(s->c, IObuff);
s->j = (*mb_char2bytes)(s->c, IObuff); IObuff[s->j] = NUL; // exclude composing chars
IObuff[s->j] = NUL; // exclude composing chars put_on_cmdline(IObuff, s->j, true);
put_on_cmdline(IObuff, s->j, true);
} else {
IObuff[0] = s->c;
put_on_cmdline(IObuff, 1, true);
}
} }
return command_line_changed(s); return command_line_changed(s);
} }
@ -2372,16 +2367,11 @@ redraw:
if (IS_SPECIAL(c1)) { if (IS_SPECIAL(c1)) {
c1 = '?'; c1 = '?';
} }
if (has_mbyte) { len = utf_char2bytes(c1, (char_u *)line_ga.ga_data + line_ga.ga_len);
len = (*mb_char2bytes)(c1, (char_u *)line_ga.ga_data + line_ga.ga_len); if (c1 == '\n') {
} else {
len = 1;
((char_u *)line_ga.ga_data)[line_ga.ga_len] = c1;
}
if (c1 == '\n')
msg_putchar('\n'); msg_putchar('\n');
else if (c1 == TAB) { } else if (c1 == TAB) {
/* Don't use chartabsize(), 'ts' can be different */ // Don't use chartabsize(), 'ts' can be different.
do { do {
msg_putchar(' '); msg_putchar(' ');
} while (++vcol % 8); } while (++vcol % 8);
@ -2897,12 +2887,12 @@ static void draw_cmdline(int start, int len)
u8c = arabic_shape(u8c, NULL, &u8cc[0], pc, pc1, nc); u8c = arabic_shape(u8c, NULL, &u8cc[0], pc, pc1, nc);
newlen += (*mb_char2bytes)(u8c, arshape_buf + newlen); newlen += utf_char2bytes(u8c, arshape_buf + newlen);
if (u8cc[0] != 0) { if (u8cc[0] != 0) {
newlen += (*mb_char2bytes)(u8cc[0], arshape_buf + newlen); newlen += utf_char2bytes(u8cc[0], arshape_buf + newlen);
if (u8cc[1] != 0) if (u8cc[1] != 0) {
newlen += (*mb_char2bytes)(u8cc[1], newlen += utf_char2bytes(u8cc[1], arshape_buf + newlen);
arshape_buf + newlen); }
} }
} else { } else {
prev_c = u8c; prev_c = u8c;

20
src/nvim/getchar.c
View File

@ -315,7 +315,7 @@ static void add_char_buff(buffheader_T *buf, int c)
if (IS_SPECIAL(c)) { if (IS_SPECIAL(c)) {
len = 1; len = 1;
} else { } else {
len = mb_char2bytes(c, bytes); len = utf_char2bytes(c, bytes);
} }
for (int i = 0; i < len; i++) { for (int i = 0; i < len; i++) {
@ -978,7 +978,7 @@ void ins_char_typebuf(int c)
buf[2] = (char_u)K_THIRD(c); buf[2] = (char_u)K_THIRD(c);
buf[3] = NUL; buf[3] = NUL;
} else { } else {
buf[(*mb_char2bytes)(c, buf)] = NUL; buf[utf_char2bytes(c, buf)] = NUL;
} }
(void)ins_typebuf(buf, KeyNoremap, 0, !KeyTyped, cmd_silent); (void)ins_typebuf(buf, KeyNoremap, 0, !KeyTyped, cmd_silent);
} }
@ -3655,16 +3655,14 @@ int check_abbr(int c, char_u *ptr, int col, int mincol)
tb[j++] = (char_u)K_SECOND(c); tb[j++] = (char_u)K_SECOND(c);
tb[j++] = (char_u)K_THIRD(c); tb[j++] = (char_u)K_THIRD(c);
} else { } else {
if (c < ABBR_OFF && (c < ' ' || c > '~')) if (c < ABBR_OFF && (c < ' ' || c > '~')) {
tb[j++] = Ctrl_V; /* special char needs CTRL-V */ tb[j++] = Ctrl_V; // special char needs CTRL-V
if (has_mbyte) {
/* if ABBR_OFF has been added, remove it here */
if (c >= ABBR_OFF)
c -= ABBR_OFF;
j += (*mb_char2bytes)(c, tb + j);
} else {
tb[j++] = (char_u)c;
} }
// if ABBR_OFF has been added, remove it here.
if (c >= ABBR_OFF) {
c -= ABBR_OFF;
}
j += utf_char2bytes(c, tb + j);
} }
tb[j] = NUL; tb[j] = NUL;
/* insert the last typed char */ /* insert the last typed char */

21
src/nvim/keymap.c
View File

@ -462,14 +462,13 @@ char_u *get_special_key_name(int c, int modifiers)
string[idx++] = '_'; string[idx++] = '_';
string[idx++] = (char_u)KEY2TERMCAP0(c); string[idx++] = (char_u)KEY2TERMCAP0(c);
string[idx++] = KEY2TERMCAP1(c); string[idx++] = KEY2TERMCAP1(c);
} } else {
/* Not a special key, only modifiers, output directly */ // Not a special key, only modifiers, output directly.
else { if (utf_char2len(c) > 1) {
if (has_mbyte && (*mb_char2len)(c) > 1) idx += utf_char2bytes(c, string + idx);
idx += (*mb_char2bytes)(c, string + idx); } else if (vim_isprintc(c)) {
else if (vim_isprintc(c))
string[idx++] = (char_u)c; string[idx++] = (char_u)c;
else { } else {
s = transchar(c); s = transchar(c);
while (*s) while (*s)
string[idx++] = *s++; string[idx++] = *s++;
@ -524,14 +523,12 @@ unsigned int trans_special(const char_u **srcp, const size_t src_len,
dst[dlen++] = K_SPECIAL; dst[dlen++] = K_SPECIAL;
dst[dlen++] = (char_u)KEY2TERMCAP0(key); dst[dlen++] = (char_u)KEY2TERMCAP0(key);
dst[dlen++] = KEY2TERMCAP1(key); dst[dlen++] = KEY2TERMCAP1(key);
} else if (has_mbyte && !keycode) { } else if (!keycode) {
dlen += (unsigned int)(*mb_char2bytes)(key, dst + dlen); dlen += (unsigned int)utf_char2bytes(key, dst + dlen);
} else if (keycode) { } else {
char_u *after = add_char2buf(key, dst + dlen); char_u *after = add_char2buf(key, dst + dlen);
assert(after >= dst && (uintmax_t)(after - dst) <= UINT_MAX); assert(after >= dst && (uintmax_t)(after - dst) <= UINT_MAX);
dlen = (unsigned int)(after - dst); dlen = (unsigned int)(after - dst);
} else {
dst[dlen++] = (char_u)key;
} }
return dlen; return dlen;

1
src/nvim/mbyte.h
View File

@ -48,7 +48,6 @@ enum { MAX_MCO = 6 };
// TODO(bfredl): eventually we should keep only one of the namings // TODO(bfredl): eventually we should keep only one of the namings
#define mb_ptr2len utfc_ptr2len #define mb_ptr2len utfc_ptr2len
#define mb_char2len utf_char2len #define mb_char2len utf_char2len
#define mb_char2bytes utf_char2bytes
#define mb_char2cells utf_char2cells #define mb_char2cells utf_char2cells
/// Flags for vimconv_T /// Flags for vimconv_T

2
src/nvim/message.c
View File

@ -1121,7 +1121,7 @@ void msg_putchar_attr(int c, int attr)
buf[2] = (char)K_THIRD(c); buf[2] = (char)K_THIRD(c);
buf[3] = NUL; buf[3] = NUL;
} else { } else {
buf[(*mb_char2bytes)(c, (char_u *)buf)] = NUL; buf[utf_char2bytes(c, (char_u *)buf)] = NUL;
} }
msg_puts_attr(buf, attr); msg_puts_attr(buf, attr);
} }

2
src/nvim/misc1.c
View File

@ -1398,7 +1398,7 @@ void ins_bytes_len(char_u *p, size_t len)
void ins_char(int c) void ins_char(int c)
{ {
char_u buf[MB_MAXBYTES + 1]; char_u buf[MB_MAXBYTES + 1];
size_t n = (size_t)(*mb_char2bytes)(c, buf); size_t n = (size_t)utf_char2bytes(c, buf);
// When "c" is 0x100, 0x200, etc. we don't want to insert a NUL byte. // When "c" is 0x100, 0x200, etc. we don't want to insert a NUL byte.
// Happens for CTRL-Vu9900. // Happens for CTRL-Vu9900.

9
src/nvim/ops.c
View File

@ -1737,13 +1737,8 @@ int op_replace(oparg_T *oap, int c)
if (had_ctrl_v_cr || (c != '\r' && c != '\n')) { if (had_ctrl_v_cr || (c != '\r' && c != '\n')) {
// strlen(newp) at this point // strlen(newp) at this point
int newp_len = bd.textcol + bd.startspaces; int newp_len = bd.textcol + bd.startspaces;
if (has_mbyte) { while (--num_chars >= 0) {
while (--num_chars >= 0) { newp_len += utf_char2bytes(c, newp + newp_len);
newp_len += (*mb_char2bytes)(c, newp + newp_len);
}
} else {
memset(newp + newp_len, c, (size_t)numc);
newp_len += numc;
} }
if (!bd.is_short) { if (!bd.is_short) {
// insert post-spaces // insert post-spaces

62
src/nvim/regexp.c
View File

@ -2538,12 +2538,11 @@ static void regc(int b)
*/ */
static void regmbc(int c) static void regmbc(int c)
{ {
if (!has_mbyte && c > 0xff) if (regcode == JUST_CALC_SIZE) {
return; regsize += utf_char2len(c);
if (regcode == JUST_CALC_SIZE) } else {
regsize += (*mb_char2len)(c); regcode += utf_char2bytes(c, regcode);
else }
regcode += (*mb_char2bytes)(c, regcode);
} }
/* /*
@ -6759,27 +6758,23 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
cc = c; cc = c;
} }
if (has_mbyte) { int totlen = utfc_ptr2len(src - 1);
int totlen = mb_ptr2len(src - 1);
if (copy) if (copy) {
mb_char2bytes(cc, dst); utf_char2bytes(cc, dst);
dst += mb_char2len(cc) - 1; }
if (enc_utf8) { dst += utf_char2len(cc) - 1;
int clen = utf_ptr2len(src - 1); int clen = utf_ptr2len(src - 1);
/* If the character length is shorter than "totlen", there // If the character length is shorter than "totlen", there
* are composing characters; copy them as-is. */ // are composing characters; copy them as-is.
if (clen < totlen) { if (clen < totlen) {
if (copy) if (copy) {
memmove(dst + 1, src - 1 + clen, memmove(dst + 1, src - 1 + clen, (size_t)(totlen - clen));
(size_t)(totlen - clen));
dst += totlen - clen;
}
} }
src += totlen - 1; dst += totlen - clen;
} else if (copy) }
*dst = cc; src += totlen - 1;
dst++; dst++;
} else { } else {
if (REG_MULTI) { if (REG_MULTI) {
@ -6856,20 +6851,19 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
if (has_mbyte) { if (has_mbyte) {
int l; int l;
/* Copy composing characters separately, one // Copy composing characters separately, one
* at a time. */ // at a time.
if (enc_utf8) l = utf_ptr2len(s) - 1;
l = utf_ptr2len(s) - 1;
else
l = mb_ptr2len(s) - 1;
s += l; s += l;
len -= l; len -= l;
if (copy) if (copy) {
mb_char2bytes(cc, dst); utf_char2bytes(cc, dst);
dst += mb_char2len(cc) - 1; }
} else if (copy) dst += utf_char2len(cc) - 1;
} else if (copy) {
*dst = cc; *dst = cc;
}
dst++; dst++;
} }

5
src/nvim/regexp_nfa.c
View File

@ -563,10 +563,7 @@ static char_u *nfa_get_match_text(nfa_state_T *start)
p = start->out->out; /* skip first char, it goes into regstart */ p = start->out->out; /* skip first char, it goes into regstart */
s = ret; s = ret;
while (p->c > 0) { while (p->c > 0) {
if (has_mbyte) s += utf_char2bytes(p->c, s);
s += (*mb_char2bytes)(p->c, s);
else
*s++ = p->c;
p = p->out; p = p->out;
} }
*s = NUL; *s = NUL;

15
src/nvim/screen.c
View File

@ -3539,7 +3539,7 @@ win_line (
xfree(p_extra_free); xfree(p_extra_free);
p_extra_free = p; p_extra_free = p;
for (i = 0; i < tab_len; i++) { for (i = 0; i < tab_len; i++) {
mb_char2bytes(lcs_tab2, p); utf_char2bytes(lcs_tab2, p);
p += mb_char2len(lcs_tab2); p += mb_char2len(lcs_tab2);
n_extra += mb_char2len(lcs_tab2) - (saved_nextra > 0 ? 1: 0); n_extra += mb_char2len(lcs_tab2) - (saved_nextra > 0 ? 1: 0);
} }
@ -5114,8 +5114,8 @@ win_redr_custom (
/* fill up with "fillchar" */ /* fill up with "fillchar" */
while (width < maxwidth && len < (int)sizeof(buf) - 1) { while (width < maxwidth && len < (int)sizeof(buf) - 1) {
len += (*mb_char2bytes)(fillchar, buf + len); len += utf_char2bytes(fillchar, buf + len);
++width; width++;
} }
buf[len] = NUL; buf[len] = NUL;
@ -5223,7 +5223,7 @@ void screen_putchar(int c, int row, int col, int attr)
{ {
char_u buf[MB_MAXBYTES + 1]; char_u buf[MB_MAXBYTES + 1];
buf[(*mb_char2bytes)(c, buf)] = NUL; buf[utf_char2bytes(c, buf)] = NUL;
screen_puts(buf, row, col, attr); screen_puts(buf, row, col, attr);
} }
@ -6949,11 +6949,8 @@ static void win_redr_ruler(win_T *wp, int always)
if (this_ru_col + o < width) { if (this_ru_col + o < width) {
// Need at least 3 chars left for get_rel_pos() + NUL. // Need at least 3 chars left for get_rel_pos() + NUL.
while (this_ru_col + o < width && RULER_BUF_LEN > i + 4) { while (this_ru_col + o < width && RULER_BUF_LEN > i + 4) {
if (has_mbyte) i += utf_char2bytes(fillchar, buffer + i);
i += (*mb_char2bytes)(fillchar, buffer + i); o++;
else
buffer[i++] = fillchar;
++o;
} }
get_rel_pos(wp, buffer + i, RULER_BUF_LEN - i); get_rel_pos(wp, buffer + i, RULER_BUF_LEN - i);
} }

11
src/nvim/search.c
View File

@ -1376,11 +1376,14 @@ int searchc(cmdarg_T *cap, int t_cmd)
*lastc = c; *lastc = c;
set_csearch_direction(dir); set_csearch_direction(dir);
set_csearch_until(t_cmd); set_csearch_until(t_cmd);
lastc_bytelen = (*mb_char2bytes)(c, lastc_bytes); lastc_bytelen = utf_char2bytes(c, lastc_bytes);
if (cap->ncharC1 != 0) { if (cap->ncharC1 != 0) {
lastc_bytelen += (*mb_char2bytes)(cap->ncharC1, lastc_bytes + lastc_bytelen); lastc_bytelen += utf_char2bytes(cap->ncharC1,
if (cap->ncharC2 != 0) lastc_bytes + lastc_bytelen);
lastc_bytelen += (*mb_char2bytes)(cap->ncharC2, lastc_bytes + lastc_bytelen); if (cap->ncharC2 != 0) {
lastc_bytelen += utf_char2bytes(cap->ncharC2,
lastc_bytes + lastc_bytelen);
}
} }
} }
} else { // repeat previous search } else { // repeat previous search

85
src/nvim/spell.c
View File

@ -2684,7 +2684,7 @@ int spell_casefold(char_u *str, int len, char_u *buf, int buflen)
return FAIL; return FAIL;
} }
c = mb_cptr2char_adv((const char_u **)&p); c = mb_cptr2char_adv((const char_u **)&p);
outi += mb_char2bytes(SPELL_TOFOLD(c), buf + outi); outi += utf_char2bytes(SPELL_TOFOLD(c), buf + outi);
} }
buf[outi] = NUL; buf[outi] = NUL;
} else { } else {
@ -3433,12 +3433,7 @@ void onecap_copy(char_u *word, char_u *wcopy, bool upper)
} else { } else {
c = SPELL_TOFOLD(c); c = SPELL_TOFOLD(c);
} }
if (has_mbyte) { l = utf_char2bytes(c, wcopy);
l = mb_char2bytes(c, wcopy);
} else {
l = 1;
wcopy[0] = c;
}
STRLCPY(wcopy + l, p, MAXWLEN - l); STRLCPY(wcopy + l, p, MAXWLEN - l);
} }
@ -3466,15 +3461,10 @@ static void allcap_copy(char_u *word, char_u *wcopy)
} else } else
c = SPELL_TOUPPER(c); c = SPELL_TOUPPER(c);
if (has_mbyte) { if (d - wcopy >= MAXWLEN - MB_MAXBYTES) {
if (d - wcopy >= MAXWLEN - MB_MAXBYTES) break;
break;
d += mb_char2bytes(c, d);
} else {
if (d - wcopy >= MAXWLEN - 1)
break;
*d++ = c;
} }
d += utf_char2bytes(c, d);
} }
*d = NUL; *d = NUL;
} }
@ -4542,21 +4532,16 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
#endif #endif
PROF_STORE(sp->ts_state) PROF_STORE(sp->ts_state)
sp->ts_state = STATE_UNSWAP; sp->ts_state = STATE_UNSWAP;
++depth; depth++;
if (has_mbyte) { fl = mb_char2len(c2);
fl = mb_char2len(c2); memmove(p, p + n, fl);
memmove(p, p + n, fl); utf_char2bytes(c, p + fl);
mb_char2bytes(c, p + fl); stack[depth].ts_fidxtry = sp->ts_fidx + n + fl;
stack[depth].ts_fidxtry = sp->ts_fidx + n + fl; } else {
} else {
p[0] = c2;
p[1] = c;
stack[depth].ts_fidxtry = sp->ts_fidx + 2;
}
} else
// If this swap doesn't work then SWAP3 won't either. // If this swap doesn't work then SWAP3 won't either.
PROF_STORE(sp->ts_state) PROF_STORE(sp->ts_state)
sp->ts_state = STATE_REP_INI; sp->ts_state = STATE_REP_INI;
}
break; break;
case STATE_UNSWAP: case STATE_UNSWAP:
@ -4565,7 +4550,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
n = MB_PTR2LEN(p); n = MB_PTR2LEN(p);
c = utf_ptr2char(p + n); c = utf_ptr2char(p + n);
memmove(p + MB_PTR2LEN(p + n), p, n); memmove(p + MB_PTR2LEN(p + n), p, n);
mb_char2bytes(c, p); utf_char2bytes(c, p);
// FALLTHROUGH // FALLTHROUGH
@ -4603,18 +4588,12 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
#endif #endif
PROF_STORE(sp->ts_state) PROF_STORE(sp->ts_state)
sp->ts_state = STATE_UNSWAP3; sp->ts_state = STATE_UNSWAP3;
++depth; depth++;
if (has_mbyte) { tl = mb_char2len(c3);
tl = mb_char2len(c3); memmove(p, p + n + fl, tl);
memmove(p, p + n + fl, tl); utf_char2bytes(c2, p + tl);
mb_char2bytes(c2, p + tl); utf_char2bytes(c, p + fl + tl);
mb_char2bytes(c, p + fl + tl); stack[depth].ts_fidxtry = sp->ts_fidx + n + fl + tl;
stack[depth].ts_fidxtry = sp->ts_fidx + n + fl + tl;
} else {
p[0] = p[2];
p[2] = c;
stack[depth].ts_fidxtry = sp->ts_fidx + 3;
}
} else { } else {
PROF_STORE(sp->ts_state) PROF_STORE(sp->ts_state)
sp->ts_state = STATE_REP_INI; sp->ts_state = STATE_REP_INI;
@ -4630,8 +4609,8 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
c = utf_ptr2char(p + n + fl); c = utf_ptr2char(p + n + fl);
tl = MB_PTR2LEN(p + n + fl); tl = MB_PTR2LEN(p + n + fl);
memmove(p + fl + tl, p, n); memmove(p + fl + tl, p, n);
mb_char2bytes(c, p); utf_char2bytes(c, p);
mb_char2bytes(c2, p + tl); utf_char2bytes(c2, p + tl);
p = p + tl; p = p + tl;
if (!soundfold && !spell_iswordp(p, curwin)) { if (!soundfold && !spell_iswordp(p, curwin)) {
@ -4677,7 +4656,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
c = utf_ptr2char(p + n); c = utf_ptr2char(p + n);
tl = MB_PTR2LEN(p + n); tl = MB_PTR2LEN(p + n);
memmove(p + tl, p, n); memmove(p + tl, p, n);
mb_char2bytes(c, p); utf_char2bytes(c, p);
// Rotate three bytes right: "123" -> "312". We change "fword" // Rotate three bytes right: "123" -> "312". We change "fword"
// here, it's changed back afterwards at STATE_UNROT3R. // here, it's changed back afterwards at STATE_UNROT3R.
@ -4698,7 +4677,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
c = utf_ptr2char(p + n); c = utf_ptr2char(p + n);
tl = MB_CPTR2LEN(p + n); tl = MB_CPTR2LEN(p + n);
memmove(p + tl, p, n); memmove(p + tl, p, n);
mb_char2bytes(c, p); utf_char2bytes(c, p);
stack[depth].ts_fidxtry = sp->ts_fidx + n + tl; stack[depth].ts_fidxtry = sp->ts_fidx + n + tl;
} else { } else {
PROF_STORE(sp->ts_state) PROF_STORE(sp->ts_state)
@ -4714,7 +4693,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
n = MB_PTR2LEN(p + tl); n = MB_PTR2LEN(p + tl);
n += MB_PTR2LEN(p + tl + n); n += MB_PTR2LEN(p + tl + n);
memmove(p, p + tl, n); memmove(p, p + tl, n);
mb_char2bytes(c, p + n); utf_char2bytes(c, p + n);
// FALLTHROUGH // FALLTHROUGH
@ -5539,7 +5518,7 @@ static bool similar_chars(slang_T *slang, int c1, int c2)
hashitem_T *hi; hashitem_T *hi;
if (c1 >= 256) { if (c1 >= 256) {
buf[mb_char2bytes(c1, buf)] = 0; buf[utf_char2bytes(c1, buf)] = 0;
hi = hash_find(&slang->sl_map_hash, buf); hi = hash_find(&slang->sl_map_hash, buf);
if (HASHITEM_EMPTY(hi)) { if (HASHITEM_EMPTY(hi)) {
m1 = 0; m1 = 0;
@ -5554,7 +5533,7 @@ static bool similar_chars(slang_T *slang, int c1, int c2)
} }
if (c2 >= 256) { if (c2 >= 256) {
buf[mb_char2bytes(c2, buf)] = 0; buf[utf_char2bytes(c2, buf)] = 0;
hi = hash_find(&slang->sl_map_hash, buf); hi = hash_find(&slang->sl_map_hash, buf);
if (HASHITEM_EMPTY(hi)) { if (HASHITEM_EMPTY(hi)) {
m2 = 0; m2 = 0;
@ -5917,9 +5896,10 @@ static void spell_soundfold_sofo(slang_T *slang, char_u *inword, char_u *res)
} }
if (c != NUL && c != prevc) { if (c != NUL && c != prevc) {
ri += mb_char2bytes(c, res + ri); ri += utf_char2bytes(c, res + ri);
if (ri + MB_MAXBYTES > MAXWLEN) if (ri + MB_MAXBYTES > MAXWLEN) {
break; break;
}
prevc = c; prevc = c;
} }
} }
@ -6439,10 +6419,11 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
// Convert wide characters in "wres" to a multi-byte string in "res". // Convert wide characters in "wres" to a multi-byte string in "res".
l = 0; l = 0;
for (n = 0; n < reslen; ++n) { for (n = 0; n < reslen; n++) {
l += mb_char2bytes(wres[n], res + l); l += utf_char2bytes(wres[n], res + l);
if (l + MB_MAXBYTES > MAXWLEN) if (l + MB_MAXBYTES > MAXWLEN) {
break; break;
}
} }
res[l] = NUL; res[l] = NUL;
} }

19
src/nvim/spellfile.c
View File

@ -1457,12 +1457,10 @@ static int read_compound(FILE *fd, slang_T *slang, int len)
*pp++ = '|'; *pp++ = '|';
atstart = 1; atstart = 1;
} else { // normal char, "[abc]" and '*' are copied as-is } else { // normal char, "[abc]" and '*' are copied as-is
if (c == '?' || c == '+' || c == '~') if (c == '?' || c == '+' || c == '~') {
*pp++ = '\\'; // "a?" becomes "a\?", "a+" becomes "a\+" *pp++ = '\\'; // "a?" becomes "a\?", "a+" becomes "a\+"
if (enc_utf8) }
pp += mb_char2bytes(c, pp); pp += utf_char2bytes(c, pp);
else
*pp++ = c;
} }
} }
@ -4244,11 +4242,8 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
// Form the <folchars> string first, we need to know its length. // Form the <folchars> string first, we need to know its length.
size_t l = 0; size_t l = 0;
for (size_t i = 128; i < 256; ++i) { for (size_t i = 128; i < 256; i++) {
if (has_mbyte) l += (size_t)utf_char2bytes(spelltab.st_fold[i], folchars + l);
l += (size_t)mb_char2bytes(spelltab.st_fold[i], folchars + l);
else
folchars[l++] = spelltab.st_fold[i];
} }
put_bytes(fd, 1 + 128 + 2 + l, 4); // <sectionlen> put_bytes(fd, 1 + 128 + 2 + l, 4); // <sectionlen>
@ -5710,9 +5705,9 @@ static void set_map_str(slang_T *lp, char_u *map)
hashitem_T *hi; hashitem_T *hi;
b = xmalloc(cl + headcl + 2); b = xmalloc(cl + headcl + 2);
mb_char2bytes(c, b); utf_char2bytes(c, b);
b[cl] = NUL; b[cl] = NUL;
mb_char2bytes(headc, b + cl + 1); utf_char2bytes(headc, b + cl + 1);
b[cl + 1 + headcl] = NUL; b[cl + 1 + headcl] = NUL;
hash = hash_hash(b); hash = hash_hash(b);
hi = hash_lookup(&lp->sl_map_hash, (const char *)b, STRLEN(b), hash); hi = hash_lookup(&lp->sl_map_hash, (const char *)b, STRLEN(b), hash);