move some string functions in lib-lib !

[apps/madmutt.git] / lib-lib / str.c

diff --git a/lib-lib/str.c b/lib-lib/str.c
index f421530..53f6ebb 100644 (file)
--- a/lib-lib/str.c
+++ b/lib-lib/str.c
@@ -220,4 +220,177 @@ int ascii_strncasecmp(const char *a, const char *b, ssize_t n)
     return 0;
 }
 
+/** \brief Retutnrs the on-screen width of the string, multi-byte aware.
+ *
+ * The function assumes that at rendering time, any non printable character or
+ * any unrecognized multibyte sequence will be replaced with a 1-cell wide
+ * char.
+ *
+ * \param[in]  s   the string;
+ * \return the width of \c s.
+ */
+ssize_t m_strwidth (const char *s)
+{
+    const ssize_t len = m_strlen(s);
+    mbstate_t mbstate;
+    ssize_t w = 0, pos = 0;
+
+    p_clear(&mbstate, 1);
+
+    while (pos < len) {
+        wchar_t wc;
+        ssize_t nb;
+
+        nb = mbrtowc(&wc, s + pos, len - pos, &mbstate);
+        switch (nb) {
+          case -2:
+            return w + 1;
+
+          case -1: /* assume we will replace that char with a ? later */
+            wc = '?';
+          default:
+            w   += iswprint(wc) ? wcwidth(wc) : 1;
+            pos -= nb;
+        }
+    }
+
+    return w;
+}
+
+ssize_t m_strformat(char *dst, ssize_t dlen, int width, const char *fmt,
+                    format_t *callback, anytype cdata, format_flag flags)
+{
+    ssize_t pos = flags & M_FORMAT_ARROWCURSOR ? 3 : 0;
+
+    m_strpad(dst, dlen, '\0', pos + 1);
+    if (!fmt)
+        return pos;
+
+    while (*fmt) {
+        int ch;
+
+        if (*fmt == '%') {
+            char ifstr[STRING], elstr[STRING], prefix[STRING];
+
+            *ifstr = *elstr = *prefix = '\0';
+
+            if (*++fmt == '%') {
+                pos += m_strputc(dst + pos, dlen - pos, *fmt++);
+                continue;
+            }
+
+            if (*fmt == '?') {
+                flags |= M_FORMAT_OPTIONAL;
+                fmt++;
+            } else {
+                ssize_t pfxlen;
+                flags &= ~M_FORMAT_OPTIONAL;
+
+                /* eat the format string */
+                pfxlen = strspn(fmt, "0123456789.-");
+                m_strncpy(prefix, sizeof(prefix), fmt, pfxlen);
+                fmt   += pfxlen;
+            }
+
+            /* save the character to switch on */
+            if (!(ch = *fmt++))
+                break;
+
+            if (flags & M_FORMAT_OPTIONAL) {
+                ssize_t iflen;
+                const char *p;
+
+                if (*fmt++ != '?')
+                    break;                /* bad format */
+
+                /* eat the `if' part of the string */
+                iflen = strcspn(fmt, "?&");
+                m_strncpy(ifstr, ssizeof(ifstr), fmt, iflen);
+                fmt  += iflen;
+
+                /* eat the `else' part of the string (optional) */
+                if (*fmt == '&')
+                    fmt++;                /* skip the & */
+
+                p = m_strchrnul(fmt, '?');
+                m_strncpy(elstr, ssizeof(elstr), fmt, p - fmt);
+                fmt = p;
+
+                if (!*fmt++)              /* move past the trailing `?' */
+                    break;                /* bad format */
+            }
+
+            switch (ch) {
+                char lower, nodots, buf[LONG_STRING];
+
+              case '>':                 /* right justify to EOL */
+                width -= m_strwidth(dst);
+
+                ch = *fmt++;            /* pad char */
+
+                if (width > 0) {
+                    m_strformat(buf, sizeof(buf), 0, fmt, callback, cdata, flags);
+                    width -= m_strwidth(buf);
+                    pos += m_strpad(dst + pos, dlen - pos, ch, width);
+                    pos += m_strcpy(dst + pos, dlen - pos, buf);
+                }
+                return pos;             /* skip rest of input */
+
+              case '|':                 /* pad to EOL */
+                width -= m_strwidth(dst);
+                return pos + m_strpad(dst + pos, dlen - pos, *fmt, width);
+
+              default:
+                lower = nodots = 0;
+
+                while (ch == '_' || ch == ':') {
+                    lower  |= ch == '_';
+                    nodots |= ch == ':';
+                    ch = *fmt++;
+                }
+
+                /* use callback function to handle this case */
+                fmt = callback(buf, sizeof (buf), ch, fmt, prefix,
+                               ifstr, elstr, cdata, flags);
+
+                if (lower)
+                    m_strtolower(buf);
+
+                if (nodots) {
+                    char *p;
+
+                    for (p = buf; *p; p++) {
+                        if (*p == '.')
+                            *p = '_';
+                    }
+                }
+
+                pos += m_strcpy(dst + pos, dlen - pos, buf);
+                break;
+            }
+            continue;
+        }
+
+        if (*fmt == '\\') {
+            if (!*++fmt)
+                break;
+            switch ((ch = *fmt++)) {
+              case 'n': pos += m_strputc(dst + pos, dlen - pos, '\n'); break;
+              case 't': pos += m_strputc(dst + pos, dlen - pos, '\t'); break;
+              case 'r': pos += m_strputc(dst + pos, dlen - pos, '\r'); break;
+              case 'f': pos += m_strputc(dst + pos, dlen - pos, '\f'); break;
+              case 'v': pos += m_strputc(dst + pos, dlen - pos, '\v'); break;
+              default:  pos += m_strputc(dst + pos, dlen - pos, ch);   break;
+            }
+        } else {
+            ssize_t len = strcspn(fmt, "%\\");
+
+            pos += m_strncpy(dst + pos, dlen - pos, fmt, len);
+            fmt += len;
+        }
+    }
+
+    return pos;
+}
+
 /*@}*/