mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-22 19:18:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

encoding: delete non-UTF-8 implementations of multibyte functions

Browse Source 
Deleted documentation was duplicated at specific utf_ implementation
This commit is contained in:
Björn Linse
2015-06-26 12:49:47 +02:00
parent 5072ab9e5b
commit 18f56c8e90
2 changed files with 9 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

261
src/nvim/mbyte.c
View File

@@ -556,99 +556,6 @@ int dbcs_class(unsigned lead, unsigned trail)
return 3; return 3;
} }
/*
* mb_char2len() function pointer.
* Return length in bytes of character "c".
* Returns 1 for a single-byte character.
*/
int latin_char2len(int c)
{
return 1;
}
static int dbcs_char2len(int c)
{
if (c >= 0x100)
return 2;
return 1;
}
/*
* mb_char2bytes() function pointer.
* Convert a character to its bytes.
* Returns the length in bytes.
*/
int latin_char2bytes(int c, char_u *buf)
{
buf[0] = c;
return 1;
}
static int dbcs_char2bytes(int c, char_u *buf)
{
if (c >= 0x100) {
buf[0] = (unsigned)c >> 8;
buf[1] = c;
/* Never use a NUL byte, it causes lots of trouble. It's an invalid
* character anyway. */
if (buf[1] == NUL)
buf[1] = '\n';
return 2;
}
buf[0] = c;
return 1;
}
/*
* mb_ptr2len() function pointer.
* Get byte length of character at "*p" but stop at a NUL.
* For UTF-8 this includes following composing characters.
* Returns 0 when *p is NUL.
*/
int latin_ptr2len(const char_u *p)
{
return MB_BYTE2LEN(*p);
}
static int dbcs_ptr2len(const char_u *p)
{
int len;
/* Check if second byte is not missing. */
len = MB_BYTE2LEN(*p);
if (len == 2 && p[1] == NUL)
len = 1;
return len;
}
/*
* mb_ptr2len_len() function pointer.
* Like mb_ptr2len(), but limit to read "size" bytes.
* Returns 0 for an empty string.
* Returns 1 for an illegal char or an incomplete byte sequence.
*/
int latin_ptr2len_len(const char_u *p, int size)
{
if (size < 1 || *p == NUL)
return 0;
return 1;
}
static int dbcs_ptr2len_len(const char_u *p, int size)
{
int len;
if (size < 1 || *p == NUL)
return 0;
if (size == 1)
return 1;
/* Check that second byte is not missing. */
len = MB_BYTE2LEN(*p);
if (len == 2 && p[1] == NUL)
len = 1;
return len;
}
/* /*
* Return true if "c" is in "table". * Return true if "c" is in "table".
*/ */
@@ -716,16 +623,8 @@ int utf_char2cells(int c)
return 1; return 1;
} }
/* /// Return the number of display cells character at "*p" occupies.
* mb_ptr2cells() function pointer. /// This doesn't take care of unprintable characters, use ptr2cells() for that.
* Return the number of display cells character at "*p" occupies.
* This doesn't take care of unprintable characters, use ptr2cells() for that.
*/
int latin_ptr2cells(const char_u *p)
{
return 1;
}
int utf_ptr2cells(const char_u *p) int utf_ptr2cells(const char_u *p)
{ {
int c; int c;
@@ -744,25 +643,8 @@ int utf_ptr2cells(const char_u *p)
return 1; return 1;
} }
int dbcs_ptr2cells(const char_u *p) /// Like utf_ptr2cells(), but limit string length to "size".
{ /// For an empty string or truncated character returns 1.
/* Number of cells is equal to number of bytes, except for euc-jp when
* the first byte is 0x8e. */
if (enc_dbcs == DBCS_JPNU && *p == 0x8e)
return 1;
return MB_BYTE2LEN(*p);
}
/*
* mb_ptr2cells_len() function pointer.
* Like mb_ptr2cells(), but limit string length to "size".
* For an empty string or truncated character returns 1.
*/
int latin_ptr2cells_len(const char_u *p, int size)
{
return 1;
}
int utf_ptr2cells_len(const char_u *p, int size) int utf_ptr2cells_len(const char_u *p, int size)
{ {
int c; int c;
@@ -783,35 +665,6 @@ int utf_ptr2cells_len(const char_u *p, int size)
return 1; return 1;
} }
static int dbcs_ptr2cells_len(const char_u *p, int size)
{
/* Number of cells is equal to number of bytes, except for euc-jp when
* the first byte is 0x8e. */
if (size <= 1 || (enc_dbcs == DBCS_JPNU && *p == 0x8e))
return 1;
return MB_BYTE2LEN(*p);
}
/*
* mb_char2cells() function pointer.
* Return the number of display cells character "c" occupies.
* Only takes care of multi-byte chars, not "^C" and such.
*/
int latin_char2cells(int c)
{
return 1;
}
static int dbcs_char2cells(int c)
{
/* Number of cells is equal to number of bytes, except for euc-jp when
* the first byte is 0x8e. */
if (enc_dbcs == DBCS_JPNU && ((unsigned)c >> 8) == 0x8e)
return 1;
/* use the first byte */
return MB_BYTE2LEN((unsigned)c >> 8);
}
/// Calculate the number of cells occupied by string `str`. /// Calculate the number of cells occupied by string `str`.
/// ///
/// @param str The source string, may not be NULL, must be a NUL-terminated /// @param str The source string, may not be NULL, must be a NUL-terminated
@@ -828,50 +681,13 @@ size_t mb_string2cells(const char_u *str)
return clen; return clen;
} }
/* /// Return number of display cells for char at ScreenLines[off].
* mb_off2cells() function pointer. /// We make sure that the offset used is less than "max_off".
* Return number of display cells for char at ScreenLines[off].
* We make sure that the offset used is less than "max_off".
*/
int latin_off2cells(unsigned off, unsigned max_off)
{
return 1;
}
int dbcs_off2cells(unsigned off, unsigned max_off)
{
/* never check beyond end of the line */
if (off >= max_off)
return 1;
/* Number of cells is equal to number of bytes, except for euc-jp when
* the first byte is 0x8e. */
if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
return 1;
return MB_BYTE2LEN(ScreenLines[off]);
}
int utf_off2cells(unsigned off, unsigned max_off) int utf_off2cells(unsigned off, unsigned max_off)
{ {
return (off + 1 < max_off && ScreenLines[off + 1] == 0) ? 2 : 1; return (off + 1 < max_off && ScreenLines[off + 1] == 0) ? 2 : 1;
} }
/*
* mb_ptr2char() function pointer.
* Convert a byte sequence into a character.
*/
int latin_ptr2char(const char_u *p)
{
return *p;
}
static int dbcs_ptr2char(const char_u *p)
{
if (MB_BYTE2LEN(*p) > 1 && p[1] != NUL)
return (p[0] << 8) + p[1];
return *p;
}
/* /*
* Convert a UTF-8 byte sequence to a wide character. * Convert a UTF-8 byte sequence to a wide character.
* If the sequence is illegal or truncated by a NUL the first byte is * If the sequence is illegal or truncated by a NUL the first byte is
@@ -1818,68 +1634,9 @@ void show_utf8(void)
msg(IObuff); msg(IObuff);
} }
/* /// Return offset from "p" to the first byte of the character it points into.
* mb_head_off() function pointer. /// If "p" points to the NUL at the end of the string return 0.
* Return offset from "p" to the first byte of the character it points into. /// Returns 0 when already at the first byte of a character.
* If "p" points to the NUL at the end of the string return 0.
* Returns 0 when already at the first byte of a character.
*/
int latin_head_off(const char_u *base, const char_u *p)
{
return 0;
}
int dbcs_head_off(const char_u *base, const char_u *p)
{
/* It can't be a trailing byte when not using DBCS, at the start of the
* string or the previous byte can't start a double-byte. */
if (p <= base || MB_BYTE2LEN(p[-1]) == 1 || *p == NUL) {
return 0;
}
/* This is slow: need to start at the base and go forward until the
* byte we are looking for. Return 1 when we went past it, 0 otherwise. */
const char_u *q = base;
while (q < p) {
q += dbcs_ptr2len(q);
}
return (q == p) ? 0 : 1;
}
/*
* Special version of dbcs_head_off() that works for ScreenLines[], where
* single-width DBCS_JPNU characters are stored separately.
*/
int dbcs_screen_head_off(const char_u *base, const char_u *p)
{
/* It can't be a trailing byte when not using DBCS, at the start of the
* string or the previous byte can't start a double-byte.
* For euc-jp an 0x8e byte in the previous cell always means we have a
* lead byte in the current cell. */
if (p <= base
|| (enc_dbcs == DBCS_JPNU && p[-1] == 0x8e)
|| MB_BYTE2LEN(p[-1]) == 1
|| *p == NUL)
return 0;
/* This is slow: need to start at the base and go forward until the
* byte we are looking for. Return 1 when we went past it, 0 otherwise.
* For DBCS_JPNU look out for 0x8e, which means the second byte is not
* stored as the next byte. */
const char_u *q = base;
while (q < p) {
if (enc_dbcs == DBCS_JPNU && *q == 0x8e) {
++q;
}
else {
q += dbcs_ptr2len(q);
}
}
return (q == p) ? 0 : 1;
}
int utf_head_off(const char_u *base, const char_u *p) int utf_head_off(const char_u *base, const char_u *p)
{ {
int c; int c;

3
src/nvim/screen.c
View File

@@ -5459,9 +5459,6 @@ void screen_puts_len(char_u *text, int textlen, int row, int col, int attr)
/* If we detected the next character needs to be redrawn, but the text /* If we detected the next character needs to be redrawn, but the text
* doesn't extend up to there, update the character here. */ * doesn't extend up to there, update the character here. */
if (force_redraw_next && col < screen_Columns) { if (force_redraw_next && col < screen_Columns) {
if (l_enc_dbcs != 0 && dbcs_off2cells(off, max_off) > 1)
screen_char_2(off, row, col);
else
screen_char(off, row, col); screen_char(off, row, col);
} }
} }