/** \file string.c Memory allocation and string handling functions. */
-#define _GNU_SOURCE
+#include "para.h"
#include <pwd.h>
#include <sys/utsname.h> /* uname() */
-
-#include <string.h>
#include <regex.h>
-
#include <langinfo.h>
#include <wchar.h>
#include <wctype.h>
-#include "para.h"
#include "string.h"
#include "error.h"
* A wrapper for realloc(3). It calls \p exit(\p EXIT_FAILURE) on errors,
* i.e. there is no need to check the return value in the caller.
*
- * \return A pointer to the newly allocated memory, which is suitably aligned
- * for any kind of variable and may be different from \a p.
+ * \return A pointer to newly allocated memory which is suitably aligned for
+ * any kind of variable and may be different from \a p.
*
* \sa realloc(3).
*/
* \return This function either returns a pointer to a string that must be
* freed by the caller or aborts without returning.
*
- * \sa printf(3), xasprintf().
+ * \sa printf(3), \ref xasprintf().
*/
__must_check __printf_1_2 __malloc char *make_message(const char *fmt, ...)
{
* return \a a without making a copy of \a a. Otherwise, construct the
* concatenation \a c, free \a a (but not \a b) and return \a c.
*
- * \sa strcat(3)
+ * \sa strcat(3).
*/
__must_check __malloc char *para_strcat(char *a, const char *b)
{
char *next_cr;
next_cr = memchr(start, '\n', buf + size - start);
- next_null = memchr(start, '\0', buf + size - start);
+ next_null = memchr(start, '\0', next_cr?
+ next_cr - start : buf + size - start);
if (!next_cr && !next_null)
break;
- if (next_cr && next_null) {
- end = next_cr < next_null? next_cr : next_null;
- } else if (next_null) {
+ if (next_null)
end = next_null;
- } else
+ else
end = next_cr;
num_lines++;
if (!(flags & FELF_DISCARD_FIRST) || start != buf) {
*
* \return Standard.
*
- * \sa para_atoi32(), strtol(3), atoi(3).
+ * \sa \ref para_atoi32(), strtol(3), atoi(3).
*/
int para_atoi64(const char *str, int64_t *value)
{
tmp = strtoll(str, &endptr, 10);
if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN))
return -E_ATOI_OVERFLOW;
- if (errno != 0 && tmp == 0) /* other error */
- return -E_STRTOLL;
+ /*
+ * If there were no digits at all, strtoll() stores the original value
+ * of str in *endptr.
+ */
if (endptr == str)
return -E_ATOI_NO_DIGITS;
+ /*
+ * The implementation may also set errno and return 0 in case no
+ * conversion was performed.
+ */
+ if (errno != 0 && tmp == 0)
+ return -E_ATOI_NO_DIGITS;
if (*endptr != '\0') /* Further characters after number */
return -E_ATOI_JUNK_AT_END;
*value = tmp;
*
* \return Standard.
*
- * \sa para_atoi64().
+ * \sa \ref para_atoi64().
*/
int para_atoi32(const char *str, int32_t *value)
{
return LL_CRIT;
if (loglevel_equal(txt, "emerg"))
return LL_EMERG;
- return -1;
+ return -E_BAD_LL;
}
static int get_next_word(const char *buf, const char *delim, char **word)
* Split a buffer into words.
*
* This parser honors single and double quotes, backslash-escaped characters
- * and special characters like \p \\n. The result contains pointers to copies
- * of the words contained in \a buf and has to be freed by using \ref
- * free_argv().
+ * and special characters like \\n. The result contains pointers to copies of
+ * the words contained in buf and has to be freed by using \ref free_argv().
*
* \param buf The buffer to be split.
* \param delim Each character in this string is treated as a separator.
* \param result The array of words is returned here.
*
- * \return Number of words in \a buf, negative on errors.
+ * It's OK to pass NULL as the buffer argument. This is equivalent to passing
+ * the empty string.
+ *
+ * \return Number of words in buf, negative on errors. The array returned
+ * through the result pointer is NULL terminated.
*/
int create_argv(const char *buf, const char *delim, char ***result)
{
return have_utf8;
}
-/*
- * glibc's wcswidth returns -1 if the string contains a tab character, which
- * makes the function next to useless. The two functions below are taken from
- * mutt.
- */
-
-#define IsWPrint(wc) (iswprint(wc) || wc >= 0xa0)
-
-static int mutt_wcwidth(wchar_t wc, size_t pos)
+static int xwcwidth(wchar_t wc, size_t pos)
{
int n;
+ /* special-case for tab */
if (wc == 0x09) /* tab */
return (pos | 7) + 1 - pos;
n = wcwidth(wc);
- if (IsWPrint(wc) && n > 0)
- return n;
- if (!(wc & ~0x7f))
- return 2;
- if (!(wc & ~0xffff))
- return 6;
- return 10;
+ /* wcswidth() returns -1 for non-printable characters */
+ return n >= 0? n : 1;
}
-static size_t mutt_wcswidth(const wchar_t *s, size_t n)
+static size_t xwcswidth(const wchar_t *s, size_t n)
{
size_t w = 0;
while (n--)
- w += mutt_wcwidth(*s++, w);
+ w += xwcwidth(*s++, w);
return w;
}
if (mbret == (size_t)-1 || mbret == (size_t)-2)
return -ERRNO_TO_PARA_ERROR(EILSEQ);
bytes_parsed += mbret;
- cells_skipped += mutt_wcwidth(wc, cells_skipped);
+ cells_skipped += xwcwidth(wc, cells_skipped);
}
*bytes_to_skip = bytes_parsed;
return 1;
return -ERRNO_TO_PARA_ERROR(errno);
if (num_wchars == 0)
return 0;
- dest = para_malloc(num_wchars * sizeof(*dest));
+ dest = para_malloc((num_wchars + 1) * sizeof(*dest));
src = s;
memset(&state, 0, sizeof(state));
num_wchars = mbsrtowcs(dest, &src, num_wchars, &state);
assert(num_wchars > 0 && num_wchars != (size_t)-1);
- *result = mutt_wcswidth(dest, num_wchars);
+ *result = xwcswidth(dest, num_wchars);
free(dest);
return 1;
}
+
+/**
+ * Truncate and sanitize a (wide character) string.
+ *
+ * This replaces all non-printable characters by spaces and makes sure that the
+ * modified string does not exceed the given maximal width.
+ *
+ * \param src The source string in multi-byte form.
+ * \param max_width The maximal number of cells the result may occupy.
+ * \param result Sanitized multi-byte string, must be freed by caller.
+ * \param width The width of the sanitized string, always <= max_width.
+ *
+ * The function is wide-character aware but falls back to C strings for
+ * non-UTF-8 locales.
+ *
+ * \return Standard. On success, *result points to a sanitized copy of the
+ * given string. This copy was allocated with malloc() and should hence be
+ * freed when the caller is no longer interested in the result.
+ *
+ * The function fails if the given string contains an invalid multibyte
+ * sequence. In this case, *result is set to NULL, and *width to zero.
+ */
+__must_check int sanitize_str(const char *src, size_t max_width,
+ char **result, size_t *width)
+{
+ mbstate_t state;
+ static wchar_t *wcs;
+ size_t num_wchars, n;
+
+ if (!utf8_mode()) {
+ *result = para_strdup(src);
+ /* replace non-printable characters by spaces */
+ for (n = 0; n < max_width && src[n]; n++) {
+ if (!isprint((unsigned char)src[n]))
+ (*result)[n] = ' ';
+ }
+ (*result)[n] = '\0';
+ *width = n;
+ return 0;
+ }
+ *result = NULL;
+ *width = 0;
+ memset(&state, 0, sizeof(state));
+ num_wchars = mbsrtowcs(NULL, &src, 0, &state);
+ if (num_wchars == (size_t)-1)
+ return -ERRNO_TO_PARA_ERROR(errno);
+ wcs = para_malloc((num_wchars + 1) * sizeof(*wcs));
+ memset(&state, 0, sizeof(state));
+ num_wchars = mbsrtowcs(wcs, &src, num_wchars + 1, &state);
+ assert(num_wchars != (size_t)-1);
+ for (n = 0; n < num_wchars && *width < max_width; n++) {
+ if (!iswprint(wcs[n]))
+ wcs[n] = L' ';
+ *width += xwcwidth(wcs[n], *width);
+ }
+ wcs[n] = L'\0';
+ n = wcstombs(NULL, wcs, 0) + 1;
+ *result = para_malloc(n);
+ num_wchars = wcstombs(*result, wcs, n);
+ assert(num_wchars != (size_t)-1);
+ free(wcs);
+ return 1;
+}
projects / paraslash.git / blobdiff