56 if (!s || (*s ==
'\0'))
60 mbstate_t mbstate = { 0 };
64 k = mbrtowc(&wc, s, n, &mbstate);
67 return ((k == (
size_t) (-1)) || (k == (
size_t) (-2))) ? -1 : k;
95 if ((clen == 1) && ispunct(*name))
110 for (; *name; name += clen)
115 if ((clen == 1) && (isspace(*name) || (*name ==
'-')))
120 while (*name && (isspace(*name) || (*name ==
'-')))
140 int l, w = 0, nl = 0;
145 if (mbtowc(&wc, p, MB_CUR_MAX) >= 0)
152 if ((wc == L
'\t') || (nl && (wc == L
' ')))
160 else if (display && (wc ==
'\n'))
222 const wchar_t *s0 = s;
242 mbstate_t mbstate = { 0 };
246 for (; slen && (dlen >= MB_LEN_MAX); dest += k, dlen -= k, src++, slen--)
248 k = wcrtomb(dest, *src, &mbstate);
249 if (k == (
size_t) (-1))
254 if (dlen >= MB_LEN_MAX)
256 dest += wcrtomb(dest, 0, &mbstate);
262 char buf[3 * MB_LEN_MAX];
265 for (; slen && p - buf < dlen; p += k, src++, slen--)
267 k = wcrtomb(p, *src, &mbstate);
268 if (k == (
size_t) (-1))
271 p += wcrtomb(p, 0, &mbstate);
276 memcpy(dest, buf, p - buf);
281 memcpy(dest, buf, dlen);
282 dest[dlen - 1] =
'\0';
296 if (!pwbuf || !pwbuflen || !buf)
300 mbstate_t mbstate = { 0 };
302 wchar_t *wbuf = *pwbuf;
303 size_t wbuflen = *pwbuflen;
307 memset(&mbstate, 0,
sizeof(mbstate));
308 for (; (k = mbrtowc(&wc, buf, MB_LEN_MAX, &mbstate)) &&
309 k != (
size_t) (-1) && k != (
size_t) (-2);
319 if ((*buf !=
'\0') && ((k == (
size_t) -1) || (k == (
size_t) -2)))
345 static const wchar_t shell_chars[] = L
"<>&()$?*;{}| ";
346 return wcschr(shell_chars, ch);
363 mbstate_t mbstate = { 0 };
366 memset(&mbstate, 0,
sizeof(mbstate));
368 for (; (l = mbrtowc(&wc, s, MB_CUR_MAX, &mbstate)) != 0; s += l)
370 if (l == (
size_t) -2)
372 if (l == (
size_t) -1)
374 if (iswalpha((wint_t) wc) && iswupper((wint_t) wc))
391 if ((wc == (
wchar_t) 0x00ad) ||
392 (wc == (
wchar_t) 0x200e) ||
393 (wc == (
wchar_t) 0x200f) ||
394 (wc == (
wchar_t) 0xfeff))
401 if ((wc >= (
wchar_t) 0x2066) && (wc <= (
wchar_t) 0x2069))
406 if ((wc >= (
wchar_t) 0x202a) && (wc <= (
wchar_t) 0x202e))
430 char scratch[MB_LEN_MAX + 1];
432 mbstate_t mbstate1 = { 0 };
433 mbstate_t mbstate2 = { 0 };
436 for (; (k = mbrtowc(&wc, p, MB_LEN_MAX, &mbstate1)); p += k)
438 if ((k == (
size_t) -1) || (k == (
size_t) -2))
441 memset(&mbstate1, 0,
sizeof(mbstate1));
448 k2 = wcrtomb(scratch, wc, &mbstate2);
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
General purpose object for storing and parsing strings.
int mutt_mb_charlen(const char *s, int *width)
Count the bytes in a (multibyte) character.
void mutt_mb_wcstombs(char *dest, size_t dlen, const wchar_t *src, size_t slen)
Convert a string from wide to multibyte characters.
bool mutt_mb_is_shell_char(wchar_t ch)
Is character not typically part of a pathname.
int mutt_mb_filter_unprintable(char **s)
Replace unprintable characters.
size_t mutt_mb_width_ceiling(const wchar_t *s, size_t n, int w1)
Keep the end of the string on-screen.
bool OptLocales
(pseudo) set if user has valid locale definition
bool mutt_mb_get_initials(const char *name, char *buf, size_t buflen)
Turn a name into initials.
bool mutt_mb_is_display_corrupting_utf8(wchar_t wc)
Will this character corrupt the display?
size_t mutt_mb_mbstowcs(wchar_t **pwbuf, size_t *pwbuflen, size_t i, const char *buf)
Convert a string from multibyte to wide characters.
int mutt_mb_width(const char *str, int col, bool display)
Measure a string's display width (in screen columns)
int mutt_mb_wcswidth(const wchar_t *s, size_t n)
Measure the screen width of a string.
bool mutt_mb_is_lower(const char *s)
Does a multi-byte string contain only lowercase characters?
int mutt_mb_wcwidth(wchar_t wc)
Measure the screen width of a character.
Multi-byte String manipulation functions.
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
void mutt_mem_realloc(void *ptr, size_t size)
Resize a block of memory on the heap.
Memory management wrappers.
bool CharsetIsUtf8
Is the user's current character set utf-8?
wchar_t ReplacementChar
When a Unicode character can't be displayed, use this instead.
Conversion between different character encodings.
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
String manipulation functions.
String manipulation buffer.
char * data
Pointer to data.