/* vi:set ts=8 sts=4 sw=4 noet:

*

* VIM - Vi IMproved by Bram Moolenaar

*

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

* See README.txt for an overview of the Vim source code.

*/

#include "vim.h"

#if defined(HAVE_WCHAR_H)

# include <wchar.h> /* for towupper() and towlower() */

#endif

static int win_nolbr_chartabsize(win_T *wp, char_u *s, colnr_T col, int *headp);

static unsigned nr2hex(unsigned c);

static int chartab_initialized = FALSE;

/* b_chartab[] is an array of 32 bytes, each bit representing one of the

* characters 0-255. */

#define SET_CHARTAB(buf, c) (buf)->b_chartab[(unsigned)(c) >> 3] |= (1 << ((c) & 0x7))

#define RESET_CHARTAB(buf, c) (buf)->b_chartab[(unsigned)(c) >> 3] &= ~(1 << ((c) & 0x7))

#define GET_CHARTAB(buf, c) ((buf)->b_chartab[(unsigned)(c) >> 3] & (1 << ((c) & 0x7)))

/* table used below, see init_chartab() for an explanation */

static char_u g_chartab[256];

/*

* Flags for g_chartab[].

*/

#define CT_CELL_MASK 0x07 /* mask: nr of display cells (1, 2 or 4) */

#define CT_PRINT_CHAR 0x10 /* flag: set for printable chars */

#define CT_ID_CHAR 0x20 /* flag: set for ID chars */

#define CT_FNAME_CHAR 0x40 /* flag: set for file name chars */

static int in_win_border(win_T *wp, colnr_T vcol);

/*

* Fill g_chartab[]. Also fills curbuf->b_chartab[] with flags for keyword

* characters for current buffer.

*

* Depends on the option settings 'iskeyword', 'isident', 'isfname',

* 'isprint' and 'encoding'.

*

* The index in g_chartab[] depends on 'encoding':

* - For non-multi-byte index with the byte (same as the character).

* - For DBCS index with the first byte.

* - For UTF-8 index with the character (when first byte is up to 0x80 it is

* the same as the character, if the first byte is 0x80 and above it depends

* on further bytes).

*

* The contents of g_chartab[]:

* - The lower two bits, masked by CT_CELL_MASK, give the number of display

* cells the character occupies (1 or 2). Not valid for UTF-8 above 0x80.

* - CT_PRINT_CHAR bit is set when the character is printable (no need to

* translate the character before displaying it). Note that only DBCS

* characters can have 2 display cells and still be printable.

* - CT_FNAME_CHAR bit is set when the character can be in a file name.

* - CT_ID_CHAR bit is set when the character can be in an identifier.

*

* Return FAIL if 'iskeyword', 'isident', 'isfname' or 'isprint' option has an

* error, OK otherwise.

*/

int

init_chartab(void)

{

return buf_init_chartab(curbuf, TRUE);

}

int

buf_init_chartab(

buf_T *buf,

int global) /* FALSE: only set buf->b_chartab[] */

{

int c;

int c2;

char_u *p;

int i;

int tilde;

int do_isalpha;

if (global)

{

/*

* Set the default size for printable characters:

* From <Space> to '~' is 1 (printable), others are 2 (not printable).

* This also inits all 'isident' and 'isfname' flags to FALSE.

*

* EBCDIC: all chars below ' ' are not printable, all others are

* printable.

*/

c = 0;

while (c < ' ')

g_chartab[c++] = (dy_flags & DY_UHEX) ? 4 : 2;

#ifdef EBCDIC

while (c < 255)

#else

while (c <= '~')

#endif

g_chartab[c++] = 1 + CT_PRINT_CHAR;

while (c < 256)

{

/* UTF-8: bytes 0xa0 - 0xff are printable (latin1) */

if (enc_utf8 && c >= 0xa0)

g_chartab[c++] = CT_PRINT_CHAR + 1;

/* euc-jp characters starting with 0x8e are single width */

else if (enc_dbcs == DBCS_JPNU && c == 0x8e)

g_chartab[c++] = CT_PRINT_CHAR + 1;

/* other double-byte chars can be printable AND double-width */

else if (enc_dbcs != 0 && MB_BYTE2LEN(c) == 2)

g_chartab[c++] = CT_PRINT_CHAR + 2;

else

/* the rest is unprintable by default */

g_chartab[c++] = (dy_flags & DY_UHEX) ? 4 : 2;

}

/* Assume that every multi-byte char is a filename character. */

for (c = 1; c < 256; ++c)

if ((enc_dbcs != 0 && MB_BYTE2LEN(c) > 1)

|| (enc_dbcs == DBCS_JPNU && c == 0x8e)

|| (enc_utf8 && c >= 0xa0))

g_chartab[c] |= CT_FNAME_CHAR;

}

/*

* Init word char flags all to FALSE

*/

vim_memset(buf->b_chartab, 0, (size_t)32);

if (enc_dbcs != 0)

for (c = 0; c < 256; ++c)

{

/* double-byte characters are probably word characters */

if (MB_BYTE2LEN(c) == 2)

SET_CHARTAB(buf, c);

}

#ifdef FEAT_LISP

/*

* In lisp mode the '-' character is included in keywords.

*/

if (buf->b_p_lisp)

SET_CHARTAB(buf, '-');

#endif

/* Walk through the 'isident', 'iskeyword', 'isfname' and 'isprint'

* options Each option is a list of characters, character numbers or

* ranges, separated by commas, e.g.: "200-210,x,#-178,-"

*/

for (i = global ? 0 : 3; i <= 3; ++i)

{

if (i == 0)

p = p_isi; /* first round: 'isident' */

else if (i == 1)

p = p_isp; /* second round: 'isprint' */

else if (i == 2)

p = p_isf; /* third round: 'isfname' */

else /* i == 3 */

p = buf->b_p_isk; /* fourth round: 'iskeyword' */

while (*p)

{

tilde = FALSE;

do_isalpha = FALSE;

if (*p == '^' && p[1] != NUL)

{

tilde = TRUE;

++p;

}

if (VIM_ISDIGIT(*p))

c = getdigits(&p);

else

if (has_mbyte)

c = mb_ptr2char_adv(&p);

else

c = *p++;

c2 = -1;

if (*p == '-' && p[1] != NUL)

{

++p;

if (VIM_ISDIGIT(*p))

c2 = getdigits(&p);

else

if (has_mbyte)

c2 = mb_ptr2char_adv(&p);

else

c2 = *p++;

}

if (c <= 0 || c >= 256 || (c2 < c && c2 != -1) || c2 >= 256

|| !(*p == NUL || *p == ','))

return FAIL;

if (c2 == -1) /* not a range */

{

/*

* A single '@' (not "@-@"):

* Decide on letters being ID/printable/keyword chars with

* standard function isalpha(). This takes care of locale for

* single-byte characters).

*/

if (c == '@')

{

do_isalpha = TRUE;

c = 1;

c2 = 255;

}

else

c2 = c;

}

while (c <= c2)

{

/* Use the MB_ functions here, because isalpha() doesn't

* work properly when 'encoding' is "latin1" and the locale is

* "C". */

if (!do_isalpha || MB_ISLOWER(c) || MB_ISUPPER(c))

{

if (i == 0) /* (re)set ID flag */

{

if (tilde)

g_chartab[c] &= ~CT_ID_CHAR;

else

g_chartab[c] |= CT_ID_CHAR;

}

else if (i == 1) /* (re)set printable */

{

if ((c < ' '

#ifndef EBCDIC

|| c > '~'

#endif

// For double-byte we keep the cell width, so

// that we can detect it from the first byte.

) && !(enc_dbcs && MB_BYTE2LEN(c) == 2))

{

if (tilde)

{

g_chartab[c] = (g_chartab[c] & ~CT_CELL_MASK)

+ ((dy_flags & DY_UHEX) ? 4 : 2);

g_chartab[c] &= ~CT_PRINT_CHAR;

}

else

{

g_chartab[c] = (g_chartab[c] & ~CT_CELL_MASK) + 1;

g_chartab[c] |= CT_PRINT_CHAR;

}

}

}

else if (i == 2) /* (re)set fname flag */

{

if (tilde)

g_chartab[c] &= ~CT_FNAME_CHAR;

else

g_chartab[c] |= CT_FNAME_CHAR;

}

else /* i == 3 */ /* (re)set keyword flag */

{

if (tilde)

RESET_CHARTAB(buf, c);

else

SET_CHARTAB(buf, c);

}

}

++c;

}

c = *p;

p = skip_to_option_part(p);

if (c == ',' && *p == NUL)

/* Trailing comma is not allowed. */

return FAIL;

}

}

chartab_initialized = TRUE;

return OK;

}

/*

* Translate any special characters in buf[bufsize] in-place.

* The result is a string with only printable characters, but if there is not

* enough room, not all characters will be translated.

*/

void

trans_characters(

char_u *buf,

int bufsize)

{

int len; /* length of string needing translation */

int room; /* room in buffer after string */

char_u *trs; /* translated character */

int trs_len; /* length of trs[] */

len = (int)STRLEN(buf);

room = bufsize - len;

while (*buf != 0)

{

/* Assume a multi-byte character doesn't need translation. */

if (has_mbyte && (trs_len = (*mb_ptr2len)(buf)) > 1)

len -= trs_len;

else

{

trs = transchar_byte(*buf);

trs_len = (int)STRLEN(trs);

if (trs_len > 1)

{

room -= trs_len - 1;

if (room <= 0)

return;

mch_memmove(buf + trs_len, buf + 1, (size_t)len);

}

mch_memmove(buf, trs, (size_t)trs_len);

--len;

}

buf += trs_len;

}

}

/*

* Translate a string into allocated memory, replacing special chars with

* printable chars. Returns NULL when out of memory.

*/

char_u *

transstr(char_u *s)

{

char_u *res;

char_u *p;

int l, len, c;

char_u hexbuf[11];

if (has_mbyte)

{

/* Compute the length of the result, taking account of unprintable

* multi-byte characters. */

len = 0;

p = s;

while (*p != NUL)

{

if ((l = (*mb_ptr2len)(p)) > 1)

{

c = (*mb_ptr2char)(p);

p += l;

if (vim_isprintc(c))

len += l;

else

{

transchar_hex(hexbuf, c);

len += (int)STRLEN(hexbuf);

}

}

else

{

l = byte2cells(*p++);

if (l > 0)

len += l;

else

len += 4; /* illegal byte sequence */

}

}

res = alloc(len + 1);

}

else

res = alloc(vim_strsize(s) + 1);

if (res != NULL)

{

*res = NUL;

p = s;

while (*p != NUL)

{

if (has_mbyte && (l = (*mb_ptr2len)(p)) > 1)

{

c = (*mb_ptr2char)(p);

if (vim_isprintc(c))

STRNCAT(res, p, l); /* append printable multi-byte char */

else

transchar_hex(res + STRLEN(res), c);

p += l;

}

else

STRCAT(res, transchar_byte(*p++));

}

}

return res;

}

/*

* Convert the string "str[orglen]" to do ignore-case comparing. Uses the

* current locale.

* When "buf" is NULL returns an allocated string (NULL for out-of-memory).

* Otherwise puts the result in "buf[buflen]".

*/

char_u *

str_foldcase(

char_u *str,

int orglen,

char_u *buf,

int buflen)

{

garray_T ga;

int i;

int len = orglen;

#define GA_CHAR(i) ((char_u *)ga.ga_data)[i]

#define GA_PTR(i) ((char_u *)ga.ga_data + i)

#define STR_CHAR(i) (buf == NULL ? GA_CHAR(i) : buf[i])

#define STR_PTR(i) (buf == NULL ? GA_PTR(i) : buf + i)

/* Copy "str" into "buf" or allocated memory, unmodified. */

if (buf == NULL)

{

ga_init2(&ga, 1, 10);

if (ga_grow(&ga, len + 1) == FAIL)

return NULL;

mch_memmove(ga.ga_data, str, (size_t)len);

ga.ga_len = len;

}

else

{

if (len >= buflen) /* Ugly! */

len = buflen - 1;

mch_memmove(buf, str, (size_t)len);

}

if (buf == NULL)

GA_CHAR(len) = NUL;

else

buf[len] = NUL;

/* Make each character lower case. */

i = 0;

while (STR_CHAR(i) != NUL)

{

if (enc_utf8 || (has_mbyte && MB_BYTE2LEN(STR_CHAR(i)) > 1))

{

if (enc_utf8)

{

int c = utf_ptr2char(STR_PTR(i));

int olen = utf_ptr2len(STR_PTR(i));

int lc = utf_tolower(c);

/* Only replace the character when it is not an invalid

* sequence (ASCII character or more than one byte) and

* utf_tolower() doesn't return the original character. */

if ((c < 0x80 || olen > 1) && c != lc)

{

int nlen = utf_char2len(lc);

/* If the byte length changes need to shift the following

* characters forward or backward. */

if (olen != nlen)

{

if (nlen > olen)

{

if (buf == NULL

? ga_grow(&ga, nlen - olen + 1) == FAIL

: len + nlen - olen >= buflen)

{

/* out of memory, keep old char */

lc = c;

nlen = olen;

}

}

if (olen != nlen)

{

if (buf == NULL)

{

STRMOVE(GA_PTR(i) + nlen, GA_PTR(i) + olen);

ga.ga_len += nlen - olen;

}

else

{

STRMOVE(buf + i + nlen, buf + i + olen);

len += nlen - olen;

}

}

}

(void)utf_char2bytes(lc, STR_PTR(i));

}

}

/* skip to next multi-byte char */

i += (*mb_ptr2len)(STR_PTR(i));

}

else

{

if (buf == NULL)

GA_CHAR(i) = TOLOWER_LOC(GA_CHAR(i));

else

buf[i] = TOLOWER_LOC(buf[i]);

++i;

}

}

if (buf == NULL)

return (char_u *)ga.ga_data;

return buf;

}

/*

* Catch 22: g_chartab[] can't be initialized before the options are

* initialized, and initializing options may cause transchar() to be called!

* When chartab_initialized == FALSE don't use g_chartab[].

* Does NOT work for multi-byte characters, c must be <= 255.

* Also doesn't work for the first byte of a multi-byte, "c" must be a

* character!

*/

static char_u transchar_buf[7];

char_u *

transchar(int c)

{

int i;

i = 0;

if (IS_SPECIAL(c)) /* special key code, display as ~@ char */

{

transchar_buf[0] = '~';

transchar_buf[1] = '@';

i = 2;

c = K_SECOND(c);

}

if ((!chartab_initialized && (

#ifdef EBCDIC

(c >= 64 && c < 255)

#else

(c >= ' ' && c <= '~')

#endif

)) || (c < 256 && vim_isprintc_strict(c)))

{

/* printable character */

transchar_buf[i] = c;

transchar_buf[i + 1] = NUL;

}

else

transchar_nonprint(transchar_buf + i, c);

return transchar_buf;

}

/*

* Like transchar(), but called with a byte instead of a character. Checks

* for an illegal UTF-8 byte.

*/

char_u *

transchar_byte(int c)

{

if (enc_utf8 && c >= 0x80)

{

transchar_nonprint(transchar_buf, c);

return transchar_buf;

}

return transchar(c);

}

/*

* Convert non-printable character to two or more printable characters in

* "buf[]". "buf" needs to be able to hold five bytes.

* Does NOT work for multi-byte characters, c must be <= 255.

*/

void

transchar_nonprint(char_u *buf, int c)

{

if (c == NL)

c = NUL; /* we use newline in place of a NUL */

else if (c == CAR && get_fileformat(curbuf) == EOL_MAC)

c = NL; /* we use CR in place of NL in this case */

if (dy_flags & DY_UHEX) /* 'display' has "uhex" */

transchar_hex(buf, c);

#ifdef EBCDIC

/* For EBCDIC only the characters 0-63 and 255 are not printable */

else if (CtrlChar(c) != 0 || c == DEL)

#else

else if (c <= 0x7f) /* 0x00 - 0x1f and 0x7f */

#endif

{

buf[0] = '^';

#ifdef EBCDIC

if (c == DEL)

buf[1] = '?'; /* DEL displayed as ^? */

else

buf[1] = CtrlChar(c);

#else

buf[1] = c ^ 0x40; /* DEL displayed as ^? */

#endif

buf[2] = NUL;

}

else if (enc_utf8 && c >= 0x80)

{

transchar_hex(buf, c);

}

#ifndef EBCDIC

else if (c >= ' ' + 0x80 && c <= '~' + 0x80) /* 0xa0 - 0xfe */

{

buf[0] = '|';

buf[1] = c - 0x80;

buf[2] = NUL;

}

#else

else if (c < 64)

{

buf[0] = '~';

buf[1] = MetaChar(c);

buf[2] = NUL;

}

#endif

else /* 0x80 - 0x9f and 0xff */

{

/*

* TODO: EBCDIC I don't know what to do with this chars, so I display

* them as '~?' for now

*/

buf[0] = '~';

#ifdef EBCDIC

buf[1] = '?'; /* 0xff displayed as ~? */

#else

buf[1] = (c - 0x80) ^ 0x40; /* 0xff displayed as ~? */

#endif

buf[2] = NUL;

}

}

void

transchar_hex(char_u *buf, int c)

{

int i = 0;

buf[0] = '<';

if (c > 255)

{

buf[++i] = nr2hex((unsigned)c >> 12);

buf[++i] = nr2hex((unsigned)c >> 8);

}

buf[++i] = nr2hex((unsigned)c >> 4);

buf[++i] = nr2hex((unsigned)c);

buf[++i] = '>';

buf[++i] = NUL;

}

/*

* Convert the lower 4 bits of byte "c" to its hex character.

* Lower case letters are used to avoid the confusion of <F1> being 0xf1 or

* function key 1.

*/

static unsigned

nr2hex(unsigned c)

{

if ((c & 0xf) <= 9)

return (c & 0xf) + '0';

return (c & 0xf) - 10 + 'a';

}

/*

* Return number of display cells occupied by byte "b".

* Caller must make sure 0 <= b <= 255.

* For multi-byte mode "b" must be the first byte of a character.

* A TAB is counted as two cells: "^I".

* For UTF-8 mode this will return 0 for bytes >= 0x80, because the number of

* cells depends on further bytes.

*/

int

byte2cells(int b)

{

if (enc_utf8 && b >= 0x80)

return 0;

return (g_chartab[b] & CT_CELL_MASK);

}

/*

* Return number of display cells occupied by character "c".

* "c" can be a special key (negative number) in which case 3 or 4 is returned.

* A TAB is counted as two cells: "^I" or four: "<09>".

*/

int

char2cells(int c)

{

if (IS_SPECIAL(c))

return char2cells(K_SECOND(c)) + 2;

if (c >= 0x80)

{

/* UTF-8: above 0x80 need to check the value */

if (enc_utf8)

return utf_char2cells(c);

/* DBCS: double-byte means double-width, except for euc-jp with first

* byte 0x8e */

if (enc_dbcs != 0 && c >= 0x100)

{

if (enc_dbcs == DBCS_JPNU && ((unsigned)c >> 8) == 0x8e)

return 1;

return 2;

}

}

return (g_chartab[c & 0xff] & CT_CELL_MASK);

}

/*

* Return number of display cells occupied by character at "*p".

* A TAB is counted as two cells: "^I" or four: "<09>".

*/

int

ptr2cells(char_u *p)

{

/* For UTF-8 we need to look at more bytes if the first byte is >= 0x80. */

if (enc_utf8 && *p >= 0x80)

return utf_ptr2cells(p);

/* For DBCS we can tell the cell count from the first byte. */

return (g_chartab[*p] & CT_CELL_MASK);

}

/*

* Return the number of character cells string "s" will take on the screen,

* counting TABs as two characters: "^I".

*/

int

vim_strsize(char_u *s)

{

return vim_strnsize(s, (int)MAXCOL);

}

/*

* Return the number of character cells string "s[len]" will take on the

* screen, counting TABs as two characters: "^I".

*/

int

vim_strnsize(char_u *s, int len)

{

int size = 0;

while (*s != NUL && --len >= 0)

if (has_mbyte)

{

int l = (*mb_ptr2len)(s);

size += ptr2cells(s);

s += l;

len -= l - 1;

}

else

size += byte2cells(*s++);

return size;

}

/*

* Return the number of characters 'c' will take on the screen, taking

* into account the size of a tab.

* Use a define to make it fast, this is used very often!!!

* Also see getvcol() below.

*/

#ifdef FEAT_VARTABS

# define RET_WIN_BUF_CHARTABSIZE(wp, buf, p, col) \

if (*(p) == TAB && (!(wp)->w_p_list || lcs_tab1)) \

{ \

return tabstop_padding(col, (buf)->b_p_ts, (buf)->b_p_vts_array); \

} \

else \

return ptr2cells(p);

#else

# define RET_WIN_BUF_CHARTABSIZE(wp, buf, p, col) \

if (*(p) == TAB && (!(wp)->w_p_list || lcs_tab1)) \

{ \

int ts; \

ts = (buf)->b_p_ts; \

return (int)(ts - (col % ts)); \

} \

else \

return ptr2cells(p);

#endif

int

chartabsize(char_u *p, colnr_T col)

{

RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, p, col)

}

#ifdef FEAT_LINEBREAK

static int

win_chartabsize(win_T *wp, char_u *p, colnr_T col)

{

RET_WIN_BUF_CHARTABSIZE(wp, wp->w_buffer, p, col)

}

#endif

/*

* Return the number of characters the string 's' will take on the screen,

* taking into account the size of a tab.

*/

int

linetabsize(char_u *s)

{

return linetabsize_col(0, s);

}

/*

* Like linetabsize(), but starting at column "startcol".

*/

int

linetabsize_col(int startcol, char_u *s)

{

colnr_T col = startcol;

char_u *line = s; /* pointer to start of line, for breakindent */

while (*s != NUL)

col += lbr_chartabsize_adv(line, &s, col);

return (int)col;

}

/*

* Like linetabsize(), but for a given window instead of the current one.

*/

int

win_linetabsize(win_T *wp, char_u *line, colnr_T len)

{

colnr_T col = 0;

char_u *s;

for (s = line; *s != NUL && (len == MAXCOL || s < line + len);

MB_PTR_ADV(s))

col += win_lbr_chartabsize(wp, line, s, col, NULL);

return (int)col;

}

/*

* Return TRUE if 'c' is a normal identifier character:

* Letters and characters from the 'isident' option.

*/

int

vim_isIDc(int c)

{

return (c > 0 && c < 0x100 && (g_chartab[c] & CT_ID_CHAR));

}

/*

* return TRUE if 'c' is a keyword character: Letters and characters from

* 'iskeyword' option for the current buffer.

* For multi-byte characters mb_get_class() is used (builtin rules).

*/

int

vim_iswordc(int c)

{

return vim_iswordc_buf(c, curbuf);

}

int

vim_iswordc_buf(int c, buf_T *buf)

{

if (c >= 0x100)

{

if (enc_dbcs != 0)

return dbcs_class((unsigned)c >> 8, (unsigned)(c & 0xff)) >= 2;

if (enc_utf8)

return utf_class_buf(c, buf) >= 2;

return FALSE;

}

return (c > 0 && GET_CHARTAB(buf, c) != 0);

}

/*

* Just like vim_iswordc() but uses a pointer to the (multi-byte) character.

*/

int

vim_iswordp(char_u *p)

{

return vim_iswordp_buf(p, curbuf);

}

int

vim_iswordp_buf(char_u *p, buf_T *buf)

{

int c = *p;

if (has_mbyte && MB_BYTE2LEN(c) > 1)

c = (*mb_ptr2char)(p);

return vim_iswordc_buf(c, buf);

}

/*

* return TRUE if 'c' is a valid file-name character

* Assume characters above 0x100 are valid (multi-byte).

*/

int

vim_isfilec(int c)

{

return (c >= 0x100 || (c > 0 && (g_chartab[c] & CT_FNAME_CHAR)));

}

/*

* return TRUE if 'c' is a valid file-name character or a wildcard character

* Assume characters above 0x100 are valid (multi-byte).

* Explicitly interpret ']' as a wildcard character as mch_has_wildcard("]")

* returns false.

*/

int

vim_isfilec_or_wc(int c)

{

char_u buf[2];

buf[0] = (char_u)c;

buf[1] = NUL;

return vim_isfilec(c) || c == ']' || mch_has_wildcard(buf);

}

/*

* Return TRUE if 'c' is a printable character.

* Assume characters above 0x100 are printable (multi-byte), except for

* Unicode.

*/

int

vim_isprintc(int c)

{

if (enc_utf8 && c >= 0x100)

return utf_printable(c);

return (c >= 0x100 || (c > 0 && (g_chartab[c] & CT_PRINT_CHAR)));

}

/*

* Strict version of vim_isprintc(c), don't return TRUE if "c" is the head

* byte of a double-byte character.

*/

int

vim_isprintc_strict(int c)

{

if (enc_dbcs != 0 && c < 0x100 && MB_BYTE2LEN(c) > 1)

return FALSE;

if (enc_utf8 && c >= 0x100)

return utf_printable(c);

return (c >= 0x100 || (c > 0 && (g_chartab[c] & CT_PRINT_CHAR)));

}

/*

* like chartabsize(), but also check for line breaks on the screen

*/

int

lbr_chartabsize(

char_u *line UNUSED, /* start of the line */

unsigned char *s,

colnr_T col)

{

#ifdef FEAT_LINEBREAK

if (!curwin->w_p_lbr && *p_sbr == NUL && !curwin->w_p_bri)

{

#endif

if (curwin->w_p_wrap)

return win_nolbr_chartabsize(curwin, s, col, NULL);

RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, s, col)

#ifdef FEAT_LINEBREAK

}

return win_lbr_chartabsize(curwin, line == NULL ? s : line, s, col, NULL);

#endif

}

/*

* Call lbr_chartabsize() and advance the pointer.

*/

int

lbr_chartabsize_adv(

char_u *line, /* start of the line */

char_u **s,

colnr_T col)

{

int retval;

retval = lbr_chartabsize(line, *s, col);

MB_PTR_ADV(*s);

return retval;

}

/*

* This function is used very often, keep it fast!!!!

*

* If "headp" not NULL, set *headp to the size of what we for 'showbreak'

* string at start of line. Warning: *headp is only set if it's a non-zero

* value, init to 0 before calling.

*/

int

win_lbr_chartabsize(

win_T *wp,

char_u *line UNUSED, /* start of the line */

char_u *s,

colnr_T col,

int *headp UNUSED)

{

#ifdef FEAT_LINEBREAK

int c;

int size;

colnr_T col2;

colnr_T col_adj = 0; /* col + screen size of tab */

colnr_T colmax;

int added;

int mb_added = 0;

int numberextra;

char_u *ps;

int tab_corr = (*s == TAB);

int n;

/*

* No 'linebreak', 'showbreak' and 'breakindent': return quickly.

*/

if (!wp->w_p_lbr && !wp->w_p_bri && *p_sbr == NUL)

#endif

{