mirror of
https://github.com/neovim/neovim.git
synced 2025-02-25 18:55:25 -06:00
Remove some occrrences of enc_utf8 and has_mbyte
Removing uses and related dead code in the locallity of changes of the two parent commits.
This commit is contained in:
ZviRackover
parent
cd3b2e4b6b
commit
071aab5148
@ -476,10 +476,7 @@ bool leftcol_changed(void)
|
||||
|
||||
int gchar_cursor(void)
|
||||
{
|
||||
if (has_mbyte) {
|
||||
return utf_ptr2char(get_cursor_pos_ptr());
|
||||
}
|
||||
return (int)(*get_cursor_pos_ptr());
|
||||
return utf_ptr2char(get_cursor_pos_ptr());
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -2311,24 +2311,14 @@ static void ins_compl_longest_match(compl_T *match)
|
||||
p = compl_leader;
|
||||
s = match->cp_str;
|
||||
while (*p != NUL) {
|
||||
if (has_mbyte) {
|
||||
c1 = utf_ptr2char(p);
|
||||
c2 = utf_ptr2char(s);
|
||||
} else {
|
||||
c1 = *p;
|
||||
c2 = *s;
|
||||
}
|
||||
if (match->cp_icase ? (mb_tolower(c1) != mb_tolower(c2))
|
||||
: (c1 != c2)) {
|
||||
c1 = utf_ptr2char(p);
|
||||
c2 = utf_ptr2char(s);
|
||||
|
||||
if (match->cp_icase ? (mb_tolower(c1) != mb_tolower(c2)) : (c1 != c2)) {
|
||||
break;
|
||||
}
|
||||
if (has_mbyte) {
|
||||
MB_PTR_ADV(p);
|
||||
MB_PTR_ADV(s);
|
||||
} else {
|
||||
++p;
|
||||
++s;
|
||||
}
|
||||
MB_PTR_ADV(p);
|
||||
MB_PTR_ADV(s);
|
||||
}
|
||||
|
||||
if (*p != NUL) {
|
||||
|
||||
@ -701,13 +701,12 @@ open_line (
|
||||
replace_push(NUL); /* end of extra blanks */
|
||||
if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES)) {
|
||||
while ((*p_extra == ' ' || *p_extra == '\t')
|
||||
&& (!enc_utf8
|
||||
|| !utf_iscomposing(utf_ptr2char(p_extra + 1)))
|
||||
) {
|
||||
if (REPLACE_NORMAL(State))
|
||||
&& !utf_iscomposing(utf_ptr2char(p_extra + 1))) {
|
||||
if (REPLACE_NORMAL(State)) {
|
||||
replace_push(*p_extra);
|
||||
++p_extra;
|
||||
++less_cols_off;
|
||||
}
|
||||
p_extra++;
|
||||
less_cols_off++;
|
||||
}
|
||||
}
|
||||
if (*p_extra != NUL) {
|
||||
@ -1749,12 +1748,7 @@ del_lines (
|
||||
|
||||
int gchar_pos(pos_T *pos)
|
||||
{
|
||||
char_u *ptr = ml_get_pos(pos);
|
||||
|
||||
if (has_mbyte) {
|
||||
return utf_ptr2char(ptr);
|
||||
}
|
||||
return (int)(*ptr);
|
||||
return utf_ptr2char(ml_get_pos(pos));
|
||||
}
|
||||
|
||||
/*
|
||||
@ -2390,12 +2384,12 @@ int get_keystroke(void)
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (has_mbyte) {
|
||||
if (MB_BYTE2LEN(n) > len)
|
||||
continue; /* more bytes to get */
|
||||
buf[len >= buflen ? buflen - 1 : len] = NUL;
|
||||
n = utf_ptr2char(buf);
|
||||
if (MB_BYTE2LEN(n) > len) {
|
||||
// more bytes to get.
|
||||
continue;
|
||||
}
|
||||
buf[len >= buflen ? buflen - 1 : len] = NUL;
|
||||
n = utf_ptr2char(buf);
|
||||
#ifdef UNIX
|
||||
if (n == intr_char)
|
||||
n = ESC;
|
||||
|
||||
@ -772,14 +772,9 @@ static int get_equi_class(char_u **pp)
|
||||
char_u *p = *pp;
|
||||
|
||||
if (p[1] == '=') {
|
||||
if (has_mbyte)
|
||||
l = (*mb_ptr2len)(p + 2);
|
||||
l = (*mb_ptr2len)(p + 2);
|
||||
if (p[l + 2] == '=' && p[l + 3] == ']') {
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(p + 2);
|
||||
} else {
|
||||
c = p[2];
|
||||
}
|
||||
c = utf_ptr2char(p + 2);
|
||||
*pp += l + 4;
|
||||
return c;
|
||||
}
|
||||
@ -1108,14 +1103,9 @@ static int get_coll_element(char_u **pp)
|
||||
char_u *p = *pp;
|
||||
|
||||
if (p[0] != NUL && p[1] == '.') {
|
||||
if (has_mbyte)
|
||||
l = (*mb_ptr2len)(p + 2);
|
||||
l = (*mb_ptr2len)(p + 2);
|
||||
if (p[l + 2] == '.' && p[l + 3] == ']') {
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(p + 2);
|
||||
} else {
|
||||
c = p[2];
|
||||
}
|
||||
c = utf_ptr2char(p + 2);
|
||||
*pp += l + 4;
|
||||
return c;
|
||||
}
|
||||
@ -1301,11 +1291,7 @@ static regprog_T *bt_regcomp(char_u *expr, int re_flags)
|
||||
}
|
||||
|
||||
if (OP(scan) == EXACTLY) {
|
||||
if (has_mbyte) {
|
||||
r->regstart = utf_ptr2char(OPERAND(scan));
|
||||
} else {
|
||||
r->regstart = *OPERAND(scan);
|
||||
}
|
||||
r->regstart = utf_ptr2char(OPERAND(scan));
|
||||
} else if (OP(scan) == BOW
|
||||
|| OP(scan) == EOW
|
||||
|| OP(scan) == NOTHING
|
||||
@ -1313,11 +1299,7 @@ static regprog_T *bt_regcomp(char_u *expr, int re_flags)
|
||||
|| OP(scan) == MCLOSE + 0 || OP(scan) == NCLOSE) {
|
||||
char_u *regnext_scan = regnext(scan);
|
||||
if (OP(regnext_scan) == EXACTLY) {
|
||||
if (has_mbyte) {
|
||||
r->regstart = utf_ptr2char(OPERAND(regnext_scan));
|
||||
} else {
|
||||
r->regstart = *OPERAND(regnext_scan);
|
||||
}
|
||||
r->regstart = utf_ptr2char(OPERAND(regnext_scan));
|
||||
}
|
||||
}
|
||||
|
||||
@ -2416,20 +2398,16 @@ collection:
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (has_mbyte) {
|
||||
int len;
|
||||
|
||||
/* produce a multibyte character, including any
|
||||
* following composing characters */
|
||||
startc = utf_ptr2char(regparse);
|
||||
len = (*mb_ptr2len)(regparse);
|
||||
if (enc_utf8 && utf_char2len(startc) != len)
|
||||
startc = -1; /* composing chars */
|
||||
while (--len >= 0)
|
||||
regc(*regparse++);
|
||||
} else {
|
||||
startc = *regparse++;
|
||||
regc(startc);
|
||||
// produce a multibyte character, including any
|
||||
// following composing characters.
|
||||
startc = utf_ptr2char(regparse);
|
||||
int len = utfc_ptr2len(regparse);
|
||||
if (utf_char2len(startc) != len) {
|
||||
// composing chars
|
||||
startc = -1;
|
||||
}
|
||||
while (--len >= 0) {
|
||||
regc(*regparse++);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2910,19 +2888,13 @@ static int peekchr(void)
|
||||
* Next character can never be (made) magic?
|
||||
* Then backslashing it won't do anything.
|
||||
*/
|
||||
if (has_mbyte) {
|
||||
curchr = utf_ptr2char(regparse + 1);
|
||||
} else {
|
||||
curchr = c;
|
||||
}
|
||||
curchr = utf_ptr2char(regparse + 1);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
if (has_mbyte) {
|
||||
curchr = utf_ptr2char(regparse);
|
||||
}
|
||||
curchr = utf_ptr2char(regparse);
|
||||
}
|
||||
|
||||
return curchr;
|
||||
@ -3474,11 +3446,7 @@ static long bt_regexec_both(char_u *line,
|
||||
if (prog->regmust != NULL) {
|
||||
int c;
|
||||
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(prog->regmust);
|
||||
} else {
|
||||
c = *prog->regmust;
|
||||
}
|
||||
c = utf_ptr2char(prog->regmust);
|
||||
s = line + col;
|
||||
|
||||
// This is used very often, esp. for ":global". Use two versions of
|
||||
@ -3509,17 +3477,11 @@ static long bt_regexec_both(char_u *line,
|
||||
|
||||
/* Simplest case: Anchored match need be tried only once. */
|
||||
if (prog->reganch) {
|
||||
int c;
|
||||
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(regline + col);
|
||||
} else {
|
||||
c = regline[col];
|
||||
}
|
||||
int c = utf_ptr2char(regline + col);
|
||||
if (prog->regstart == NUL
|
||||
|| prog->regstart == c
|
||||
|| (rex.reg_ic
|
||||
&& (((enc_utf8 && utf_fold(prog->regstart) == utf_fold(c)))
|
||||
&& (utf_fold(prog->regstart) == utf_fold(c)
|
||||
|| (c < 255 && prog->regstart < 255
|
||||
&& mb_tolower(prog->regstart) == mb_tolower(c))))) {
|
||||
retval = regtry(prog, col);
|
||||
@ -3866,13 +3828,10 @@ regmatch (
|
||||
} else if (rex.reg_line_lbr && WITH_NL(op) && *reginput == '\n') {
|
||||
ADVANCE_REGINPUT();
|
||||
} else {
|
||||
if (WITH_NL(op))
|
||||
if (WITH_NL(op)) {
|
||||
op -= ADD_NL;
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(reginput);
|
||||
} else {
|
||||
c = *reginput;
|
||||
}
|
||||
c = utf_ptr2char(reginput);
|
||||
switch (op) {
|
||||
case BOL:
|
||||
if (reginput != regline)
|
||||
@ -6791,20 +6750,20 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
}
|
||||
c = *src++;
|
||||
}
|
||||
} else if (has_mbyte) {
|
||||
} else {
|
||||
c = utf_ptr2char(src - 1);
|
||||
}
|
||||
|
||||
/* Write to buffer, if copy is set. */
|
||||
if (func_one != (fptr_T)NULL)
|
||||
/* Turbo C complains without the typecast */
|
||||
// Write to buffer, if copy is set.
|
||||
if (func_one != NULL) {
|
||||
func_one = (fptr_T)(func_one(&cc, c));
|
||||
else if (func_all != (fptr_T)NULL)
|
||||
/* Turbo C complains without the typecast */
|
||||
func_all = (fptr_T)(func_all(&cc, c));
|
||||
else /* just copy */
|
||||
cc = c;
|
||||
|
||||
} else {
|
||||
if (func_all != NULL) {
|
||||
func_all = (fptr_T)(func_all(&cc, c));
|
||||
} else {
|
||||
// just copy
|
||||
cc = c;
|
||||
}
|
||||
}
|
||||
if (has_mbyte) {
|
||||
int totlen = mb_ptr2len(src - 1);
|
||||
|
||||
@ -6888,11 +6847,7 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
}
|
||||
dst += 2;
|
||||
} else {
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(s);
|
||||
} else {
|
||||
c = *s;
|
||||
}
|
||||
c = utf_ptr2char(s);
|
||||
|
||||
if (func_one != (fptr_T)NULL)
|
||||
/* Turbo C complains without the typecast */
|
||||
|
||||
@ -5033,13 +5033,8 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
|
||||
int curc;
|
||||
int clen;
|
||||
|
||||
if (has_mbyte) {
|
||||
curc = utf_ptr2char(reginput);
|
||||
clen = (*mb_ptr2len)(reginput);
|
||||
} else {
|
||||
curc = *reginput;
|
||||
clen = 1;
|
||||
}
|
||||
curc = utf_ptr2char(reginput);
|
||||
clen = utfc_ptr2len(reginput);
|
||||
if (curc == NUL) {
|
||||
clen = 0;
|
||||
go_to_nextline = false;
|
||||
|
||||
@ -1120,8 +1120,8 @@ int do_search(
|
||||
msgbuf = xmalloc(STRLEN(p) + 40);
|
||||
{
|
||||
msgbuf[0] = dirc;
|
||||
if (enc_utf8 && utf_iscomposing(utf_ptr2char(p))) {
|
||||
/* Use a space to draw the composing char on. */
|
||||
if (utf_iscomposing(utf_ptr2char(p))) {
|
||||
// Use a space to draw the composing char on.
|
||||
msgbuf[1] = ' ';
|
||||
STRCPY(msgbuf + 2, p);
|
||||
} else
|
||||
|
||||
188
src/nvim/spell.c
188
src/nvim/spell.c
@ -2619,16 +2619,11 @@ static bool spell_iswordp(char_u *p, win_T *wp)
|
||||
// Unlike spell_iswordp() this doesn't check for "midword" characters.
|
||||
bool spell_iswordp_nmw(const char_u *p, win_T *wp)
|
||||
{
|
||||
int c;
|
||||
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(p);
|
||||
if (c > 255) {
|
||||
return spell_mb_isword_class(mb_get_class(p), wp);
|
||||
}
|
||||
return spelltab.st_isw[c];
|
||||
int c = utf_ptr2char(p);
|
||||
if (c > 255) {
|
||||
return spell_mb_isword_class(mb_get_class(p), wp);
|
||||
}
|
||||
return spelltab.st_isw[*p];
|
||||
return spelltab.st_isw[c];
|
||||
}
|
||||
|
||||
// Returns true if word class indicates a word character.
|
||||
@ -4316,7 +4311,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
&& sp->ts_twordlen > sp->ts_tcharlen) {
|
||||
p = tword + sp->ts_twordlen - sp->ts_tcharlen;
|
||||
c = utf_ptr2char(p);
|
||||
if (enc_utf8 && utf_iscomposing(c)) {
|
||||
if (utf_iscomposing(c)) {
|
||||
// Inserting a composing char doesn't
|
||||
// count that much.
|
||||
sp->ts_score -= SCORE_INS - SCORE_INSCOMP;
|
||||
@ -4388,19 +4383,14 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
// score if the same character is following "nn" -> "n". It's
|
||||
// a bit illogical for soundfold tree but it does give better
|
||||
// results.
|
||||
if (has_mbyte) {
|
||||
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 == utf_ptr2char(fword + stack[depth].ts_fidx)) {
|
||||
stack[depth].ts_score -= SCORE_DEL - SCORE_DELDUP;
|
||||
}
|
||||
} else {
|
||||
++stack[depth].ts_fidx;
|
||||
if (fword[sp->ts_fidx] == fword[sp->ts_fidx + 1])
|
||||
stack[depth].ts_score -= SCORE_DEL - SCORE_DELDUP;
|
||||
c = utf_ptr2char(fword + sp->ts_fidx);
|
||||
stack[depth].ts_fidx += MB_PTR2LEN(fword + sp->ts_fidx);
|
||||
if (utf_iscomposing(c)) {
|
||||
stack[depth].ts_score -= SCORE_DEL - SCORE_DELCOMP;
|
||||
} else if (c == utf_ptr2char(fword + stack[depth].ts_fidx)) {
|
||||
stack[depth].ts_score -= SCORE_DEL - SCORE_DELDUP;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
// FALLTHROUGH
|
||||
@ -4515,24 +4505,14 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
break;
|
||||
}
|
||||
|
||||
if (has_mbyte) {
|
||||
n = MB_CPTR2LEN(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 = utf_ptr2char(p + n);
|
||||
}
|
||||
n = MB_CPTR2LEN(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 {
|
||||
if (p[1] == NUL) {
|
||||
c2 = NUL;
|
||||
} else if (!soundfold && !spell_iswordp(p + 1, curwin)) {
|
||||
c2 = c; // don't swap non-word char
|
||||
} else {
|
||||
c2 = p[1];
|
||||
}
|
||||
c2 = utf_ptr2char(p + n);
|
||||
}
|
||||
|
||||
// When the second character is NUL we can't swap.
|
||||
@ -4578,39 +4558,25 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
case STATE_UNSWAP:
|
||||
// Undo the STATE_SWAP swap: "21" -> "12".
|
||||
p = fword + sp->ts_fidx;
|
||||
if (has_mbyte) {
|
||||
n = MB_PTR2LEN(p);
|
||||
c = utf_ptr2char(p + n);
|
||||
memmove(p + MB_PTR2LEN(p + n), p, n);
|
||||
mb_char2bytes(c, p);
|
||||
} else {
|
||||
c = *p;
|
||||
*p = p[1];
|
||||
p[1] = c;
|
||||
}
|
||||
n = MB_PTR2LEN(p);
|
||||
c = utf_ptr2char(p + n);
|
||||
memmove(p + MB_PTR2LEN(p + n), p, n);
|
||||
mb_char2bytes(c, p);
|
||||
|
||||
// FALLTHROUGH
|
||||
|
||||
case STATE_SWAP3:
|
||||
// Swap two bytes, skipping one: "123" -> "321". We change
|
||||
// "fword" here, it's changed back afterwards at STATE_UNSWAP3.
|
||||
p = fword + sp->ts_fidx;
|
||||
if (has_mbyte) {
|
||||
n = MB_CPTR2LEN(p);
|
||||
c = utf_ptr2char(p);
|
||||
fl = MB_CPTR2LEN(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 = utf_ptr2char(p + n + fl);
|
||||
}
|
||||
n = MB_CPTR2LEN(p);
|
||||
c = utf_ptr2char(p);
|
||||
fl = MB_CPTR2LEN(p + n);
|
||||
c2 = utf_ptr2char(p + n);
|
||||
if (!soundfold && !spell_iswordp(p + n + fl, curwin)) {
|
||||
c3 = c; // don't swap non-word char
|
||||
} else {
|
||||
c = *p;
|
||||
c2 = p[1];
|
||||
if (!soundfold && !spell_iswordp(p + 2, curwin))
|
||||
c3 = c; // don't swap non-word char
|
||||
else
|
||||
c3 = p[2];
|
||||
c3 = utf_ptr2char(p + n + fl);
|
||||
}
|
||||
|
||||
// When characters are identical: "121" then SWAP3 result is
|
||||
@ -4654,22 +4620,15 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
case STATE_UNSWAP3:
|
||||
// Undo STATE_SWAP3: "321" -> "123"
|
||||
p = fword + sp->ts_fidx;
|
||||
if (has_mbyte) {
|
||||
n = MB_PTR2LEN(p);
|
||||
c2 = utf_ptr2char(p + n);
|
||||
fl = MB_PTR2LEN(p + n);
|
||||
c = utf_ptr2char(p + n + fl);
|
||||
tl = MB_PTR2LEN(p + n + fl);
|
||||
memmove(p + fl + tl, p, n);
|
||||
mb_char2bytes(c, p);
|
||||
mb_char2bytes(c2, p + tl);
|
||||
p = p + tl;
|
||||
} else {
|
||||
c = *p;
|
||||
*p = p[2];
|
||||
p[2] = c;
|
||||
++p;
|
||||
}
|
||||
n = MB_PTR2LEN(p);
|
||||
c2 = utf_ptr2char(p + n);
|
||||
fl = MB_PTR2LEN(p + n);
|
||||
c = utf_ptr2char(p + n + fl);
|
||||
tl = MB_PTR2LEN(p + n + fl);
|
||||
memmove(p + fl + tl, p, n);
|
||||
mb_char2bytes(c, p);
|
||||
mb_char2bytes(c2, p + tl);
|
||||
p = p + tl;
|
||||
|
||||
if (!soundfold && !spell_iswordp(p, curwin)) {
|
||||
// Middle char is not a word char, skip the rotate. First and
|
||||
@ -4717,19 +4676,12 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
case STATE_UNROT3L:
|
||||
// Undo ROT3L: "231" -> "123"
|
||||
p = fword + sp->ts_fidx;
|
||||
if (has_mbyte) {
|
||||
n = MB_PTR2LEN(p);
|
||||
n += MB_PTR2LEN(p + n);
|
||||
c = utf_ptr2char(p + n);
|
||||
tl = MB_PTR2LEN(p + n);
|
||||
memmove(p + tl, p, n);
|
||||
mb_char2bytes(c, p);
|
||||
} else {
|
||||
c = p[2];
|
||||
p[2] = p[1];
|
||||
p[1] = *p;
|
||||
*p = c;
|
||||
}
|
||||
n = MB_PTR2LEN(p);
|
||||
n += MB_PTR2LEN(p + n);
|
||||
c = utf_ptr2char(p + n);
|
||||
tl = MB_PTR2LEN(p + n);
|
||||
memmove(p + tl, p, n);
|
||||
mb_char2bytes(c, p);
|
||||
|
||||
// Rotate three bytes right: "123" -> "312". We change "fword"
|
||||
// here, it's changed back afterwards at STATE_UNROT3R.
|
||||
@ -4745,21 +4697,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
sp->ts_state = STATE_UNROT3R;
|
||||
++depth;
|
||||
p = fword + sp->ts_fidx;
|
||||
if (has_mbyte) {
|
||||
n = MB_CPTR2LEN(p);
|
||||
n += MB_CPTR2LEN(p + n);
|
||||
c = utf_ptr2char(p + n);
|
||||
tl = MB_CPTR2LEN(p + n);
|
||||
memmove(p + tl, p, n);
|
||||
mb_char2bytes(c, p);
|
||||
stack[depth].ts_fidxtry = sp->ts_fidx + n + tl;
|
||||
} else {
|
||||
c = p[2];
|
||||
p[2] = p[1];
|
||||
p[1] = *p;
|
||||
*p = c;
|
||||
stack[depth].ts_fidxtry = sp->ts_fidx + 3;
|
||||
}
|
||||
n = MB_CPTR2LEN(p);
|
||||
n += MB_CPTR2LEN(p + n);
|
||||
c = utf_ptr2char(p + n);
|
||||
tl = MB_CPTR2LEN(p + n);
|
||||
memmove(p + tl, p, n);
|
||||
mb_char2bytes(c, p);
|
||||
stack[depth].ts_fidxtry = sp->ts_fidx + n + tl;
|
||||
} else {
|
||||
PROF_STORE(sp->ts_state)
|
||||
sp->ts_state = STATE_REP_INI;
|
||||
@ -4769,19 +4713,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
|
||||
case STATE_UNROT3R:
|
||||
// Undo ROT3R: "312" -> "123"
|
||||
p = fword + sp->ts_fidx;
|
||||
if (has_mbyte) {
|
||||
c = utf_ptr2char(p);
|
||||
tl = MB_PTR2LEN(p);
|
||||
n = MB_PTR2LEN(p + tl);
|
||||
n += MB_PTR2LEN(p + tl + n);
|
||||
memmove(p, p + tl, n);
|
||||
mb_char2bytes(c, p + n);
|
||||
} else {
|
||||
c = *p;
|
||||
*p = p[1];
|
||||
p[1] = p[2];
|
||||
p[2] = c;
|
||||
}
|
||||
c = utf_ptr2char(p);
|
||||
tl = MB_PTR2LEN(p);
|
||||
n = MB_PTR2LEN(p + tl);
|
||||
n += MB_PTR2LEN(p + tl + n);
|
||||
memmove(p, p + tl, n);
|
||||
mb_char2bytes(c, p + n);
|
||||
|
||||
// FALLTHROUGH
|
||||
|
||||
case STATE_REP_INI:
|
||||
@ -5666,11 +5604,7 @@ add_suggestion (
|
||||
break;
|
||||
MB_PTR_BACK(goodword, pgood);
|
||||
MB_PTR_BACK(su->su_badptr, pbad);
|
||||
if (has_mbyte) {
|
||||
if (utf_ptr2char(pgood) != utf_ptr2char(pbad)) {
|
||||
break;
|
||||
}
|
||||
} else if (*pgood != *pbad) {
|
||||
if (utf_ptr2char(pgood) != utf_ptr2char(pbad)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -4101,13 +4101,9 @@ get_syn_options(
|
||||
return NULL;
|
||||
}
|
||||
} else if (flagtab[fidx].argtype == 11 && arg[5] == '=') {
|
||||
/* cchar=? */
|
||||
if (has_mbyte) {
|
||||
*conceal_char = utf_ptr2char(arg + 6);
|
||||
arg += mb_ptr2len(arg + 6) - 1;
|
||||
} else {
|
||||
*conceal_char = arg[6];
|
||||
}
|
||||
// cchar=?
|
||||
*conceal_char = utf_ptr2char(arg + 6);
|
||||
arg += mb_ptr2len(arg + 6) - 1;
|
||||
if (!vim_isprintc_strict(*conceal_char)) {
|
||||
EMSG(_("E844: invalid cchar value"));
|
||||
return NULL;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user