/*
* Initialize the text for a new sign
*/
static int
sign_define_init_text(sign_T *sp, char_u *text)
{
char_u *s;
char_u *endp;
int cells;
int len;
endp = text + (int)STRLEN(text);
// Remove backslashes so that it is possible to use a space.
for (s = text; s + 1 < endp; ++s)
if (*s == '\\')
{
STRMOVE(s, s + 1);
--endp;
}
// Count cells and check for non-printable chars
if (has_mbyte)
{
cells = 0;
for (s = text; s < endp; s += (*mb_ptr2len)(s))
{
if (!vim_isprintc((*mb_ptr2char)(s)))
break;
cells += (*mb_ptr2cells)(s);
}
}
else
{
for (s = text; s < endp; ++s)
if (!vim_isprintc(*s))
break;
cells = (int)(s - text);
}
// Currently sign text must be one or two display cells
if (s != endp || cells < 1 || cells > 2)
{
semsg(_("E239: Invalid sign text: %s"), text);
return FAIL;
}
vim_free(sp->sn_text);
// Allocate one byte more if we need to pad up
// with a space.
len = (int)(endp - text + ((cells == 1) ? 1 : 0));
sp->sn_text = vim_strnsave(text, len);
// For single character sign text, pad with a space.
if (sp->sn_text != NULL && cells == 1)
STRCPY(sp->sn_text + len - 1, " ");
return OK;
}
/*
* 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((unsigned)(len + 1));
} else
res = alloc((unsigned)(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;
}
/*
* Return a string which contains the name of the given key when the given
* modifiers are down.
*/
char_u *get_special_key_name(int c, int modifiers)
{
static char_u string[MAX_KEY_NAME_LEN + 1];
int i, idx;
int table_idx;
char_u *s;
string[0] = '<';
idx = 1;
/* Key that stands for a normal character. */
if (IS_SPECIAL(c) && KEY2TERMCAP0(c) == KS_KEY)
c = KEY2TERMCAP1(c);
/*
* Translate shifted special keys into unshifted keys and set modifier.
* Same for CTRL and ALT modifiers.
*/
if (IS_SPECIAL(c)) {
for (i = 0; modifier_keys_table[i] != 0; i += MOD_KEYS_ENTRY_SIZE)
if ( KEY2TERMCAP0(c) == (int)modifier_keys_table[i + 1]
&& (int)KEY2TERMCAP1(c) == (int)modifier_keys_table[i + 2]) {
modifiers |= modifier_keys_table[i];
c = TERMCAP2KEY(modifier_keys_table[i + 3],
modifier_keys_table[i + 4]);
break;
}
}
/* try to find the key in the special key table */
table_idx = find_special_key_in_table(c);
/*
* When not a known special key, and not a printable character, try to
* extract modifiers.
*/
if (c > 0
&& (*mb_char2len)(c) == 1
) {
if (table_idx < 0
&& (!vim_isprintc(c) || (c & 0x7f) == ' ')
&& (c & 0x80)) {
c &= 0x7f;
modifiers |= MOD_MASK_ALT;
/* try again, to find the un-alted key in the special key table */
table_idx = find_special_key_in_table(c);
}
if (table_idx < 0 && !vim_isprintc(c) && c < ' ') {
c += '@';
modifiers |= MOD_MASK_CTRL;
}
}
/* translate the modifier into a string */
for (i = 0; mod_mask_table[i].name != 'A'; i++)
if ((modifiers & mod_mask_table[i].mod_mask)
== mod_mask_table[i].mod_flag) {
string[idx++] = mod_mask_table[i].name;
string[idx++] = (char_u)'-';
}
if (table_idx < 0) { /* unknown special key, may output t_xx */
if (IS_SPECIAL(c)) {
string[idx++] = 't';
string[idx++] = '_';
string[idx++] = (char_u)KEY2TERMCAP0(c);
string[idx++] = KEY2TERMCAP1(c);
}
/* Not a special key, only modifiers, output directly */
else {
if (has_mbyte && (*mb_char2len)(c) > 1)
idx += (*mb_char2bytes)(c, string + idx);
else if (vim_isprintc(c))
string[idx++] = (char_u)c;
else {
s = transchar(c);
while (*s)
string[idx++] = *s++;
}
}
} else { /* use name of special key */
STRCPY(string + idx, key_names_table[table_idx].name);
idx = (int)STRLEN(string);
}
string[idx++] = '>';
string[idx] = NUL;
return string;
}
/// Translate a string into allocated memory, replacing special chars with
/// printable chars. Returns NULL when out of memory.
///
/// @param s
///
/// @return translated string
char_u *transstr(char_u *s)
{
char_u *res;
char_u *p;
int l, c;
char_u hexbuf[11];
if (has_mbyte) {
// Compute the length of the result, taking account of unprintable
// multi-byte characters.
size_t 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 += STRLEN(hexbuf);
}
} else {
l = byte2cells(*p++);
if (l > 0) {
len += l;
} else {
// illegal byte sequence
len += 4;
}
}
}
res = xmallocz(len);
} else {
res = xmallocz(vim_strsize(s));
}
*res = NUL;
p = s;
while (*p != NUL) {
if (has_mbyte && ((l = (*mb_ptr2len)(p)) > 1)) {
c = (*mb_ptr2char)(p);
if (vim_isprintc(c)) {
// append printable multi-byte char
STRNCAT(res, p, l);
} else {
transchar_hex(res + STRLEN(res), c);
}
p += l;
} else {
STRCAT(res, transchar_byte(*p++));
}
}
return res;
}