]> diplodocus.org Git - nmh/blobdiff - sbr/fmt_scan.c
projects / nmh / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Resized buffer and provided timezone its own buffer.
[nmh] / sbr / fmt_scan.c
diff --git a/sbr/fmt_scan.c b/sbr/fmt_scan.c
index 8f59e4b4e5b80b7dfa57acfd70d4d906a09b4502..f9aee54b0d2bd866f23bb4075424c58ee025722e 100644 (file)
--- a/sbr/fmt_scan.c
+++ b/sbr/fmt_scan.c
@@ -1,6 +1,4 @@
-
-/*
- * fmt_scan.c -- format string interpretation
+/* fmt_scan.c -- format string interpretation
  *
  * This code is Copyright (c) 2002, by the authors of nmh.  See the
  * COPYRIGHT file in the root directory of the nmh distribution for
  *
  * This code is Copyright (c) 2002, by the authors of nmh.  See the
  * COPYRIGHT file in the root directory of the nmh distribution for
@@ -10,11 +8,20 @@
  * fmt_compile (found in fmt_compile.c).
  */
 
  * fmt_compile (found in fmt_compile.c).
  */
 
-#include <h/mh.h>
-#include <h/addrsbr.h>
-#include <h/fmt_scan.h>
-#include <h/tws.h>
-#include <h/fmt_compile.h>
+#include "h/mh.h"
+#include "fmt_addr.h"
+#include "dtime.h"
+#include "strindex.h"
+#include "fmt_rfc2047.h"
+#include "uprf.h"
+#include "context_find.h"
+#include "error.h"
+#include "h/addrsbr.h"
+#include "h/fmt_scan.h"
+#include "h/tws.h"
+#include "h/fmt_compile.h"
+#include "h/utils.h"
+#include "unquote.h"
 
 #ifdef HAVE_SYS_TIME_H
 # include <sys/time.h>
 
 #ifdef HAVE_SYS_TIME_H
 # include <sys/time.h>
@@ -31,7 +38,7 @@ struct mailname fmt_mnull = { NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0,
 /*
  * static prototypes
  */
 /*
  * static prototypes
  */
-static int match (char *, char *);
+static int match (char *, char *) PURE;
 static char *get_x400_friendly (char *, char *, int);
 static int get_x400_comp (char *, char *, char *, int);
 
 static char *get_x400_friendly (char *, char *, int);
 static int get_x400_comp (char *, char *, char *, int);
 
@@ -48,24 +55,14 @@ match (char *str, char *sub)
     char *s1, *s2;
 
     while ((c1 = *sub)) {
     char *s1, *s2;
 
     while ((c1 = *sub)) {
-       c1 = (isascii((unsigned char) c1) && isalpha((unsigned char) c1) &&
-             isupper((unsigned char) c1)) ? tolower((unsigned char) c1) : c1;
-       while ((c2 = *str++) && c1 != ((isascii((unsigned char) c2) &&
-                                       isalpha((unsigned char) c2) &&
-                                       isupper((unsigned char) c2)) ?
-                                           tolower((unsigned char) c2) : c2))
+       c1 = tolower((unsigned char)c1);
+       while ((c2 = *str++) && c1 != tolower((unsigned char)c2))
            ;
        if (! c2)
            return 0;
        s1 = sub + 1; s2 = str;
            ;
        if (! c2)
            return 0;
        s1 = sub + 1; s2 = str;
-       while ((c1 = *s1++) && ((isascii((unsigned char) c1) &&
-                                isalpha((unsigned char) c1) &&
-                                isupper((unsigned char) c1)) ?
-                                       tolower(c1) : c1) ==
-                       ((isascii((unsigned char) (c2 =*s2++)) &&
-                         isalpha((unsigned char) c2) &&
-                         isupper((unsigned char) c2)) ?
-                               tolower((unsigned char) c2) : c2))
+       while ((c1 = *s1++) &&
+            tolower((unsigned char)c1) == tolower((unsigned char)(c2 = *s2++)))
            ;
        if (! c1)
            return 1;
            ;
        if (! c1)
            return 1;
@@ -73,48 +70,80 @@ match (char *str, char *sub)
     return 1;
 }
 
     return 1;
 }
 
-/*
- * copy a number to the destination subject to a maximum width
- */
-static void
-cpnumber(char **dest, int num, unsigned int wid, char fill, size_t n) {
-    int i, c;
-    char *sp;
-    char *cp = *dest;
-    char *ep = cp + n;
-
-    if (cp + wid < ep) {
-       if ((i = (num)) < 0)
-           i = -(num);
-       if ((c = (wid)) < 0)
-           c = -c;
-       sp = cp + c;
-       do {
-           *--sp = (i % 10) + '0';
-           i /= 10;
-       } while (i > 0 && sp > cp);
-       if (i > 0)
-           *sp = '?';
-       else if ((num) < 0 && sp > cp)
-           *--sp = '-';
-       while (sp > cp)
-           *--sp = fill;
-       cp += c;
+/* cpnumber formats num as a signed decimal,
+ * appending it to dest if the result doesn't exceed max.
+ * The absolute value of width is the minimum width to produce.
+ * A smaller string is padded;
+ * on the left if width is positive, else the right.
+ * Left-padding uses fill.  It is either ' ' or '0'.
+ * Right-padding is always with space. */
+void
+cpnumber(charstring_t dest, int num, int width, char fill, size_t max)
+{
+    if (width == 0 || width == INT_MIN) {
+        return;
+    }
+
+    bool padright = width < 0;
+    if (padright) {
+        width = -width; /* Can't overflow after above check. */
+    }
+    size_t w = width;
+    if (w > max) {
+        return; /* The padded result can't fit. */
+    }
+    if (num < 0 && w == 1) {
+        return; /* No room for `-' and a digit or `?'. */
+    }
+
+    char *s = m_str(num);
+    size_t len = strlen(s);
+    if (len == w) {
+        charstring_append_cstring(dest, s);
+        return;
     }
     }
-    *dest = cp;
+
+    bool neg = *s == '-';
+    if (len < w) {
+        if (padright) {
+            charstring_append_cstring(dest, s);
+            while (len++ < w) {
+                charstring_push_back(dest, ' ');
+            }
+            return;
+        }
+
+        if (neg && fill == '0') {
+            charstring_push_back(dest, *s++);
+        }
+        while (len++ < w) {
+            charstring_push_back(dest, fill);
+        }
+        charstring_append_cstring(dest, s);
+        return;
+    }
+
+    /* Transform 1234567 -> 1234?67 and -1234567 -> 1234-?7. */
+    char *news = s + len - w;
+    if (neg) {
+        *news = '-';
+    }
+    news[neg] = '?';
+    charstring_append_cstring(dest, news);
 }
 
 /*
 }
 
 /*
- * copy string from str to dest padding with the fill character to a size
- * of wid characters. if wid is negative, the string is right aligned
- * no more than n bytes are copied
+ * copy string from str to dest padding with the fill character to a
+ * size of wid characters. if wid is negative, the string is right
+ * aligned no more than max characters are copied
  */
  */
-static void
-cptrimmed(char **dest, char **ep, char *str, unsigned int wid, char fill,
-         char *epmax) {
+void
+cptrimmed(charstring_t dest, char *str, int wid, char fill, size_t max)
+{
     int remaining;     /* remaining output width available */
     int remaining;     /* remaining output width available */
-    int c, ljust;
-    int end;           /* number of input bytes remaining in str */
+    bool rjust;
+    struct charstring *trimmed;
+    size_t end;        /* number of input bytes remaining in str */
 #ifdef MULTIBYTE_SUPPORT
     int char_len;      /* bytes in current character */
     int w;
 #ifdef MULTIBYTE_SUPPORT
     int char_len;      /* bytes in current character */
     int w;
@@ -122,18 +151,21 @@ cptrimmed(char **dest, char **ep, char *str, unsigned int wid, char fill,
     char *altstr = NULL;
 #endif
     char *sp;          /* current position in source string */
     char *altstr = NULL;
 #endif
     char *sp;          /* current position in source string */
-    char *cp = *dest;  /* current position in destination string */
-    int prevCtrl = 1;
 
     /* get alignment */
 
     /* get alignment */
-    ljust = 0;
-    if ((remaining = (wid)) < 0) {
+    rjust = false;
+    if ((remaining = wid) < 0) {
        remaining = -remaining;
        remaining = -remaining;
-       ljust++;
+       rjust = true;
     }
     }
-    if ((sp = (str))) {
+    if (remaining > (int) max) { remaining = max; }
+
+    trimmed = rjust ? charstring_create(remaining) : dest;
+
+    bool prevCtrl = true;
+    if ((sp = str)) {
 #ifdef MULTIBYTE_SUPPORT
 #ifdef MULTIBYTE_SUPPORT
-       mbtowc(NULL, NULL, 0); /* reset shift state */
+       if (mbtowc(NULL, NULL, 0)) {} /* reset shift state */
 #endif
        end = strlen(str);
        while (*sp && remaining > 0 && end > 0) {
 #endif
        end = strlen(str);
        while (*sp && remaining > 0 && end > 0) {
@@ -151,22 +183,16 @@ cptrimmed(char **dest, char **ep, char *str, unsigned int wid, char fill,
                char_len = mbtowc(&wide_char, altstr, 1);
            }
 
                char_len = mbtowc(&wide_char, altstr, 1);
            }
 
-           if (char_len <= 0)
+           if (char_len <= 0) {
                break;
                break;
+           }
 
            w = wcwidth(wide_char);
 
 
            w = wcwidth(wide_char);
 
-           /*
-            * Multibyte characters can have a variable number of column
-            * widths, so use the column width to bump the end pointer when
-            * appropriate.
-            */
-           if (w >= 0  &&  char_len > 1 && epmax - *ep >= char_len - w) {
-               *ep += char_len - w;
-           }
-
-           if (w >= 0  &&  cp + w > *ep)
+           /* If w > remaining, w must be positive. */
+           if (w > remaining) {
                break;
                break;
+           }
 
            end -= char_len;
 
 
            end -= char_len;
 
@@ -182,138 +208,150 @@ cptrimmed(char **dest, char **ep, char *str, unsigned int wid, char fill,
                sp++;
 #endif
                if (!prevCtrl) {
                sp++;
 #endif
                if (!prevCtrl) {
-                   *cp++ = ' ';
+                    charstring_push_back (trimmed, ' ');
                    remaining--;
                }
 
                    remaining--;
                }
 
-               prevCtrl = 1;
+               prevCtrl = true;
                continue;
            }
                continue;
            }
-           prevCtrl = 0;
+           prevCtrl = false;
 
 #ifdef MULTIBYTE_SUPPORT
            if (w >= 0 && remaining >= w) {
 
 #ifdef MULTIBYTE_SUPPORT
            if (w >= 0 && remaining >= w) {
-               strncpy(cp, altstr ? altstr : sp, char_len);
-               cp += char_len;
+                charstring_push_back_chars (trimmed, altstr ? altstr : sp,
+                                           char_len, w);
                remaining -= w;
                altstr = NULL;
            }
            sp += char_len;
 #else
                remaining -= w;
                altstr = NULL;
            }
            sp += char_len;
 #else
-           *cp++ = *sp++;
+            charstring_push_back (trimmed, *sp++);
            remaining--;
 #endif
        }
     }
 
            remaining--;
 #endif
        }
     }
 
-    if (ljust) {
-        char *endfield;
-       if (cp + remaining > *ep)
-           remaining = *ep - cp;
-       endfield = cp + remaining;
-       if (remaining > 0) {
-           /* copy string to the right */
-           while (--cp >= *dest)
-               *(cp + remaining) = *cp;
-           /* add padding at the beginning */
-           cp += remaining;
-           for (c=remaining; c>0; c--)
-               *cp-- = fill;
-       }
-       *dest = endfield;
-    } else {
-       /* pad remaining space */
-       while (remaining-- > 0 && cp < *ep)
-               *cp++ = fill;
-       *dest = cp;
+    while (remaining-- > 0) {
+        charstring_push_back(dest, fill);
+    }
+
+    if (rjust) {
+        charstring_append(dest, trimmed);
+        charstring_free(trimmed);
     }
 }
 
     }
 }
 
+#ifdef MULTIBYTE_SUPPORT
 static void
 static void
-cpstripped (char **dest, char **end, char *max, char *str)
+cpstripped (charstring_t dest, size_t max, char *str)
 {
 {
-    int prevCtrl = 1;  /* This is 1 so we strip out leading spaces */
-    int len;
-#ifdef MULTIBYTE_SUPPORT
-    int char_len, w;
-    wchar_t wide_char;
-    char *altstr = NULL;
-#endif /* MULTIBYTE_SUPPORT */
-
-    if (!str)
-       return;
-
-    len = strlen(str);
-
-#ifdef MULTIBYTE_SUPPORT
-    mbtowc(NULL, NULL, 0);  /* Reset shift state */
-#endif /* MULTIBYTE_SUPPORT */
-
-    /*
-     * Process each character at a time; if we have multibyte support
-     * then deal with that here.
-     */
-
-    while (*str != '\0' && len > 0 && *dest < *end) {
-#ifdef MULTIBYTE_SUPPORT
-       char_len = mbtowc(&wide_char, str, len);
-       w = wcwidth(wide_char);
-
-       /*
-        * Account for multibyte characters, and increment the end pointer
-        * by the number of "extra" bytes in this character.  That's the
-        * character length (char_len) minus the column width (w).
-        */
-       if (w >= 0  &&  char_len > 1  &&  max - *end >= char_len - w) {
-           *end += char_len - w;
-       }
-
-       /*
-        * If mbrtowc() failed, then we have a character that isn't valid
-        * in the current encoding.  Replace it with a '?'.  We do that by
-        * setting the alstr variable to the value of the replacement string;
-        * altstr is used below when the bytes are copied into the output
-        * buffer.
-        */
-
-       if (char_len < 0) {
-           altstr = "?";
-           char_len = mbtowc(&wide_char, altstr, 1);
-       }
+    static bool deja_vu;
+    static char oddchar[MB_LEN_MAX * 2];
+    static size_t oddlen;
+    static char spacechar[MB_LEN_MAX * 2];
+    static size_t spacelen;
+    char *end;
+    bool squash;
+    char *src;
+    int srclen;
+    wchar_t rune;
+    int w;
 
 
-       if (char_len <= 0 || *dest + char_len > *end)
-           break;
+    if (!deja_vu) {
+        deja_vu = true;
 
 
-       len -= char_len;
+        oddlen = wcstombs(oddchar, L"?", sizeof oddchar);
+        assert(oddlen > 0);
+        assert(wcwidth(L' ') == 1); /* Need to pad in ones. */
+        spacelen = wcstombs(spacechar, L" ", sizeof spacechar);
+        assert(spacelen > 0);
+    }
 
 
-       if (iswcntrl(wide_char) || iswspace(wide_char)) {
-           str += char_len;
-#else /* MULTIBYTE_SUPPORT */
-       int c = (unsigned char) *str;
-       len--;
-       if (iscntrl(c) || isspace(c)) {
-           str++;
-#endif /* MULTIBYTE_SUPPORT */
-           if (! prevCtrl) {
-               *(*dest)++ = ' ';
-           }
+    if (!str)
+        return; /* It's unclear why no padding in this case. */
+    end = str + strlen(str);
+
+    if (mbtowc(NULL, NULL, 0))
+        {} /* Reset shift state. */
+
+    squash = true; /* Trim `space' or `cntrl' from the start. */
+    while (max) {
+        if (!*str)
+            return; /* It's unclear why no padding in this case. */
+
+        srclen = mbtowc(&rune, str, end - str);
+        if (srclen == -1) {
+            /* Invalid rune, or not enough bytes to finish it. */
+            rune = L'?';
+            src = oddchar;
+            srclen = oddlen;
+            str++; /* Skip one byte. */
+        } else {
+            src = str;
+            str += srclen;
+        }
+
+        if (iswspace(rune) || iswcntrl(rune)) {
+            if (squash)
+                continue; /* Amidst a run of these. */
+            rune = L' ';
+            src = spacechar;
+            srclen = spacelen;
+            squash = true;
+        } else
+            squash = false;
+
+        w = wcwidth(rune);
+        if (w == -1) {
+            rune = L'?';
+            w = wcwidth(rune);
+            assert(w != -1);
+            src = oddchar;
+            srclen = oddlen;
+        }
+
+        if ((size_t)w > max) {
+            /* No room for rune;  pad. */
+            while (max--)
+                charstring_push_back_chars(dest, spacechar, spacelen, 1);
+            return;
+        }
+
+        charstring_push_back_chars(dest, src, srclen, w);
+        max -= w;
+    }
+}
+#endif
 
 
-           prevCtrl = 1;
-           continue;
-       }
+#ifndef MULTIBYTE_SUPPORT
+static void
+cpstripped (charstring_t dest, size_t max, char *str)
+{
+    bool squash;
+    int c;
 
 
-       prevCtrl = 0;
+    if (!str)
+       return;
 
 
-#ifdef MULTIBYTE_SUPPORT
-       memcpy(*dest, altstr ? altstr : str, char_len);
-       str += char_len;
-       *dest += char_len;
-       altstr = NULL;
-#else /* MULTIBYE_SUPPORT */
-       *(*dest)++ = *str++
-#endif /* MULTIBYTE_SUPPORT */
+    squash = true; /* Strip leading cases. */
+    while (max--) {
+        c = (unsigned char)*str++;
+        if (!c)
+            return;
+
+       if (isspace(c) || iscntrl(c)) {
+            if (squash)
+                continue;
+            c = ' ';
+            squash = true;
+        } else
+            squash = false;
+
+       charstring_push_back(dest, (char)c);
     }
 }
     }
 }
+#endif
 
 static char *lmonth[] = { "January",  "February","March",   "April",
                          "May",      "June",    "July",    "August",
 
 static char *lmonth[] = { "January",  "February","March",   "April",
                          "May",      "June",    "July",    "August",
@@ -364,25 +402,32 @@ get_x400_comp (char *mbox, char *key, char *buffer, int buffer_len)
 }
 
 struct format *
 }
 
 struct format *
-fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
+fmt_scan (struct format *format, charstring_t scanlp, int width, int *dat,
          struct fmt_callbacks *callbacks)
 {
          struct fmt_callbacks *callbacks)
 {
-    char *cp, *ep, *sp;
-    char *savestr = NULL, *str = NULL;
-    char buffer[BUFSIZ], buffer2[BUFSIZ];
-    int i, c, ljust, n;
-    int value = 0;
+    char *sp;
+    /* If str points to part of buffer[] or buffer2[] then it must only
+     * ever point at their first element as otherwise undefined
+     * behaviour from overlapping strncpy(3)s can result. */
+    char *str, *savestr;
+    char buffer[NMH_BUFSIZ], buffer2[NMH_BUFSIZ];
+    int i, c;
+    bool rjust;
+    int value;
     time_t t;
     time_t t;
+    size_t max;
     struct format *fmt;
     struct comp *comp;
     struct tws *tws;
     struct mailname *mn;
 
     struct format *fmt;
     struct comp *comp;
     struct tws *tws;
     struct mailname *mn;
 
-    /* ep keeps track of displayed characters.  They're limited by width.
-       The total number of characters, cp - scanl + 1 (for trailing NULL),
-       includes invisible control characters and is limited by max. */
-    cp = scanl;
-    ep = scanl + (width <= (int) max ? width : (int) max) - 1;
+    /*
+     * max is the same as width, but unsigned so comparisons
+     * with charstring_chars() won't raise compile warnings.
+     */
+    max = width;
+    savestr = str = NULL;
+    value = 0;
 
     for (fmt = format; fmt->f_type != FT_DONE; fmt++)
        switch (fmt->f_type) {
 
     for (fmt = format; fmt->f_type != FT_DONE; fmt++)
        switch (fmt->f_type) {
@@ -415,81 +460,70 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
 
     fmt = format;
 
 
     fmt = format;
 
-    while (cp < ep) {
+    for ( ; charstring_chars (scanlp) < max; ) {
        switch (fmt->f_type) {
 
        case FT_COMP:
        switch (fmt->f_type) {
 
        case FT_COMP:
-           cpstripped (&cp, &ep, scanl + max - 1, fmt->f_comp->c_text);
+           cpstripped (scanlp, max - charstring_chars (scanlp),
+                        fmt->f_comp->c_text);
            break;
        case FT_COMPF:
            break;
        case FT_COMPF:
-           cptrimmed (&cp, &ep, fmt->f_comp->c_text, fmt->f_width, fmt->f_fill,
-                      scanl + max - 1);
+           cptrimmed (scanlp, fmt->f_comp->c_text, fmt->f_width,
+                      fmt->f_fill, max - charstring_chars (scanlp));
            break;
 
        case FT_LIT:
            sp = fmt->f_text;
            break;
 
        case FT_LIT:
            sp = fmt->f_text;
-           while( (c = *sp++) && cp < ep)
-               *cp++ = c;
+           while ((c = *sp++) && charstring_chars (scanlp) < max) {
+               charstring_push_back (scanlp, c);
+           }
            break;
        case FT_LITF:
            sp = fmt->f_text;
            break;
        case FT_LITF:
            sp = fmt->f_text;
-           ljust = 0;
+           rjust = false;
            i = fmt->f_width;
            if (i < 0) {
                i = -i;
            i = fmt->f_width;
            if (i < 0) {
                i = -i;
-               ljust++;                /* XXX should do something with this */
+               rjust = true;           /* XXX should do something with this */
+           }
+           while ((c = *sp++) && --i >= 0 && charstring_chars (scanlp) < max) {
+               charstring_push_back (scanlp, c);
+           }
+           while (--i >= 0 && charstring_chars (scanlp) < max) {
+               charstring_push_back (scanlp, fmt->f_fill);
            }
            }
-           while( (c = *sp++) && --i >= 0 && cp < ep)
-               *cp++ = c;
-           while( --i >= 0 && cp < ep)
-               *cp++ = fmt->f_fill;
            break;
 
        case FT_STR:
            break;
 
        case FT_STR:
-           cpstripped (&cp, &ep, scanl + max - 1, str);
+           cpstripped (scanlp, max - charstring_chars (scanlp), str);
            break;
        case FT_STRF:
            break;
        case FT_STRF:
-           cptrimmed (&cp, &ep, str, fmt->f_width, fmt->f_fill, 
-                      scanl + max - 1);
+           cptrimmed (scanlp, str, fmt->f_width, fmt->f_fill,
+                      max - charstring_chars (scanlp));
            break;
        case FT_STRLIT:
            if (str) {
                sp = str;
            break;
        case FT_STRLIT:
            if (str) {
                sp = str;
-               while ((c = *sp++) && cp < ep)
-                   *cp++ = c;
+               while ((c = *sp++) && charstring_chars (scanlp) < max) {
+                   charstring_push_back (scanlp, c);
+               }
            }
            break;
        case FT_STRLITZ:
            }
            break;
        case FT_STRLITZ:
-           if (str) {
-               size_t len = strlen (str);
-
-               /* Don't want to emit part of an escape sequence.  So if
-                  there isn't enough room in the buffer for the entire
-                  string, skip it completely. */
-               if (cp - scanl + len + 1 < max) {
-                   for (sp = str; *sp; *cp++ = *sp++) continue;
-
-                   /* This string doesn't count against the width.
-                      So increase ep the same amount as cp, only if the
-                      scan buffer will always be large enough. */
-                   if (ep - scanl + len + 1 < max) {
-                       ep += len;
-                   }
-               }
-           }
+           if (str) charstring_push_back_chars (scanlp, str, strlen (str), 0);
            break;
        case FT_STRFW:
            break;
        case FT_STRFW:
-           adios (NULL, "internal error (FT_STRFW)");
-
-       case FT_NUM:
-           n = snprintf(cp, ep - cp + 1, "%d", value);
-           if (n >= 0) {
-               if (n >= ep - cp) {
-                   cp = ep;
-               } else
-                   cp += n;
-           }
+           die("internal error (FT_STRFW)");
+
+       case FT_NUM: {
+           int num = value;
+           unsigned int wid;
+
+            for (wid = num <= 0; num; ++wid, num /= 10) {}
+           cpnumber (scanlp, value, wid, ' ',
+                     max - charstring_chars (scanlp));
            break;
            break;
+        }
        case FT_LS_KILO:
        case FT_LS_KIBI:
            {
        case FT_LS_KILO:
        case FT_LS_KIBI:
            {
@@ -507,6 +541,9 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                if (val < scale) {
                    snprintf(buffer, sizeof(buffer), "%u", val);
                } else {
                if (val < scale) {
                    snprintf(buffer, sizeof(buffer), "%u", val);
                } else {
+                   /* To prevent divide by 0, found by clang static
+                      analyzer. */
+                   if (scale == 0) { scale = 1; }
 
                    /* find correct scale for size (Kilo/Mega/Giga/Tera) */
                    for (unitcp = "KMGT"; val > (scale * scale); val /= scale) {
 
                    /* find correct scale for size (Kilo/Mega/Giga/Tera) */
                    for (unitcp = "KMGT"; val > (scale * scale); val /= scale) {
@@ -540,24 +577,25 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            }
            break;
        case FT_NUMF:
            }
            break;
        case FT_NUMF:
-           cpnumber (&cp, value, fmt->f_width, fmt->f_fill, ep - cp);
+           cpnumber (scanlp, value, fmt->f_width, fmt->f_fill,
+                     max - charstring_chars (scanlp));
            break;
 
        case FT_CHAR:
            break;
 
        case FT_CHAR:
-           *cp++ = fmt->f_char;
+           charstring_push_back (scanlp, fmt->f_char);
            break;
 
        case FT_DONE:
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
            break;
 
        case FT_DONE:
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                     str, scanl);
+                                     str, charstring_buffer (scanlp));
            goto finished;
 
        case FT_IF_S:
            if (!(value = (str && *str))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
            goto finished;
 
        case FT_IF_S:
            if (!(value = (str && *str))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                         str, scanl);
+                                         str, charstring_buffer (scanlp));
                fmt += fmt->f_skip;
                continue;
            }
                fmt += fmt->f_skip;
                continue;
            }
@@ -567,7 +605,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if (!(value = (str == NULL || *str == 0))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
            if (!(value = (str == NULL || *str == 0))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                         str, scanl);
+                                         str, charstring_buffer (scanlp));
                fmt += fmt->f_skip;
                continue;
            }
                fmt += fmt->f_skip;
                continue;
            }
@@ -577,7 +615,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if (value != fmt->f_value) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
            if (value != fmt->f_value) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                         str, scanl);
+                                         str, charstring_buffer (scanlp));
                fmt += fmt->f_skip;
                continue;
            }
                fmt += fmt->f_skip;
                continue;
            }
@@ -587,7 +625,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if (value == fmt->f_value) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
            if (value == fmt->f_value) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                         str, scanl);
+                                         str, charstring_buffer (scanlp));
                fmt += fmt->f_skip;
                continue;
            }
                fmt += fmt->f_skip;
                continue;
            }
@@ -597,7 +635,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if (value <= fmt->f_value) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
            if (value <= fmt->f_value) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                         str, scanl);
+                                         str, charstring_buffer (scanlp));
                fmt += fmt->f_skip;
                continue;
            }
                fmt += fmt->f_skip;
                continue;
            }
@@ -607,7 +645,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if (!(value = (str && match (str, fmt->f_text)))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
            if (!(value = (str && match (str, fmt->f_text)))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                         str, scanl);
+                                         str, charstring_buffer (scanlp));
                fmt += fmt->f_skip;
                continue;
            }
                fmt += fmt->f_skip;
                continue;
            }
@@ -624,7 +662,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if (!(value = (str && uprf (str, fmt->f_text)))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
            if (!(value = (str && uprf (str, fmt->f_text)))) {
                if (callbacks && callbacks->trace_func)
                    callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                         str, scanl);
+                                         str, charstring_buffer (scanlp));
                fmt += fmt->f_skip;
                continue;
            }
                fmt += fmt->f_skip;
                continue;
            }
@@ -657,7 +695,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
        case FT_GOTO:
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
        case FT_GOTO:
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                     str, scanl);
+                                     str, charstring_buffer (scanlp));
            fmt += fmt->f_skip;
            continue;
 
            fmt += fmt->f_skip;
            continue;
 
@@ -695,25 +733,27 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if (str) {
                    char *xp;
 
            if (str) {
                    char *xp;
 
-                   strncpy(buffer, str, sizeof(buffer));
+                   if (str != buffer)
+                       strncpy(buffer, str, sizeof(buffer));
                    buffer[sizeof(buffer)-1] = '\0';
                    str = buffer;
                    while (isspace((unsigned char) *str))
                            str++;
                    buffer[sizeof(buffer)-1] = '\0';
                    str = buffer;
                    while (isspace((unsigned char) *str))
                            str++;
-                   ljust = 0;
+                   rjust = false;
                    if ((i = fmt->f_width) < 0) {
                            i = -i;
                    if ((i = fmt->f_width) < 0) {
                            i = -i;
-                           ljust++;
+                           rjust = true;
                    }
 
                    }
 
-                   if (!ljust && i > 0 && (int) strlen(str) > i)
+                   if (!rjust && i > 0 && (int) strlen(str) > i)
                            str[i] = '\0';
                    xp = str;
                    xp += strlen(str) - 1;
                    while (xp > str && isspace((unsigned char) *xp))
                            *xp-- = '\0';
                            str[i] = '\0';
                    xp = str;
                    xp += strlen(str) - 1;
                    while (xp > str && isspace((unsigned char) *xp))
                            *xp-- = '\0';
-                   if (ljust && i > 0 && (int) strlen(str) > i)
+                   if (rjust && i > 0 && (int) strlen(str) > i)
                        str += strlen(str) - i;
                        str += strlen(str) - i;
+                    str = memmove(buffer, str, strlen(str) + 1);
            }
            break;
 
            }
            break;
 
@@ -736,7 +776,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                    value = 0;
            break;
        case FT_LV_CHAR_LEFT:
                    value = 0;
            break;
        case FT_LV_CHAR_LEFT:
-           value = width - (cp - scanl);
+           value = max - charstring_bytes (scanlp);
            break;
        case FT_LV_PLUS_L:
            value += fmt->f_value;
            break;
        case FT_LV_PLUS_L:
            value += fmt->f_value;
@@ -744,16 +784,22 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
        case FT_LV_MINUS_L:
            value = fmt->f_value - value;
            break;
        case FT_LV_MINUS_L:
            value = fmt->f_value - value;
            break;
+       case FT_LV_MULTIPLY_L:
+           value *= fmt->f_value;
+           break;
        case FT_LV_DIVIDE_L:
        case FT_LV_DIVIDE_L:
-           if (fmt->f_value)
-               value = value / fmt->f_value;
-           else
+            if (fmt->f_value == 0 || (fmt->f_value == -1 && value == INT_MIN)) {
+                // FIXME: Tell the user, and probably stop.
                value = 0;
                value = 0;
+            } else {
+                value /= fmt->f_value;
+            }
            break;
        case FT_LV_MODULO_L:
            if (fmt->f_value)
            break;
        case FT_LV_MODULO_L:
            if (fmt->f_value)
-               value = value % fmt->f_value;
+               value %= fmt->f_value;
            else
            else
+                // FIXME: Tell the user, and probably stop.
                value = 0;
            break;
        case FT_SAVESTR:
                value = 0;
            break;
        case FT_SAVESTR:
@@ -815,7 +861,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
        case FT_LV_RCLOCK:
            if ((value = fmt->f_comp->c_tws->tw_clock) == 0)
                value = dmktime(fmt->f_comp->c_tws);
        case FT_LV_RCLOCK:
            if ((value = fmt->f_comp->c_tws->tw_clock) == 0)
                value = dmktime(fmt->f_comp->c_tws);
-           value = time((time_t *) 0) - value;
+           value = time(NULL) - value;
            break;
        case FT_LV_DAYF:
            if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
            break;
        case FT_LV_DAYF:
            if (!(((tws = fmt->f_comp->c_tws)->tw_flags) & (TW_SEXP|TW_SIMP)))
@@ -828,14 +874,15 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                default:
                    value = -1; break;
            }
                default:
                    value = -1; break;
            }
+           break;
        case FT_LV_ZONEF:
        case FT_LV_ZONEF:
-           if ((fmt->f_comp->c_tws->tw_flags & TW_SZONE) == TW_SZEXP)
+           if (fmt->f_comp->c_tws->tw_flags & TW_SZEXP)
                    value = 1;
            else
                    value = -1;
            break;
        case FT_LV_DST:
                    value = 1;
            else
                    value = -1;
            break;
        case FT_LV_DST:
-           value = fmt->f_comp->c_tws->tw_flags & TW_DST;
+           value = fmt->f_comp->c_tws->tw_flags & TW_DST ? 1 : 0;
            break;
        case FT_LS_822DATE:
            str = dasctime (fmt->f_comp->c_tws , TW_ZONE);
            break;
        case FT_LS_822DATE:
            str = dasctime (fmt->f_comp->c_tws , TW_ZONE);
@@ -884,7 +931,8 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                goto unfriendly;
            if ((str = mn->m_pers) == NULL) {
                if ((str = mn->m_note)) {
                goto unfriendly;
            if ((str = mn->m_pers) == NULL) {
                if ((str = mn->m_note)) {
-                   strncpy (buffer, str, sizeof(buffer));
+                   if (str != buffer)
+                       strncpy (buffer, str, sizeof(buffer));
                    buffer[sizeof(buffer)-1] = '\0';
                    str = buffer;
                    if (*str == '(')
                    buffer[sizeof(buffer)-1] = '\0';
                    str = buffer;
                    if (*str == '(')
@@ -898,9 +946,10 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                            else
                                break;
                    }
                            else
                                break;
                    }
+                    str = memmove(buffer, str, strlen(str) + 1);
                } else if (!(str = get_x400_friendly (mn->m_mbox,
                                buffer, sizeof(buffer)))) {
                } else if (!(str = get_x400_friendly (mn->m_mbox,
                                buffer, sizeof(buffer)))) {
-       unfriendly: ;
+       unfriendly:
                  switch (mn->m_type) {
                    case LOCALHOST:
                        str = mn->m_mbox;
                  switch (mn->m_type) {
                    case LOCALHOST:
                        str = mn->m_mbox;
@@ -928,7 +977,8 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                /* UNQUOTEs RFC-2822 quoted-string and quoted-pair */
        case FT_LS_UNQUOTE:
            if (str) {          
                /* UNQUOTEs RFC-2822 quoted-string and quoted-pair */
        case FT_LS_UNQUOTE:
            if (str) {          
-               strncpy(buffer, str, sizeof(buffer));
+               if (str != buffer)
+                   strncpy(buffer, str, sizeof(buffer));
                /* strncpy doesn't NUL-terminate if it fills the buffer */
                buffer[sizeof(buffer)-1] = '\0';
                unquote_string(buffer, buffer2);
                /* strncpy doesn't NUL-terminate if it fills the buffer */
                buffer[sizeof(buffer)-1] = '\0';
                unquote_string(buffer, buffer2);
@@ -960,7 +1010,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                *comp->c_tws = *tws;
                comp->c_flags &= ~CF_TRUE;
            } else if ((comp->c_flags & CF_DATEFAB) == 0) {
                *comp->c_tws = *tws;
                comp->c_flags &= ~CF_TRUE;
            } else if ((comp->c_flags & CF_DATEFAB) == 0) {
-               memset ((char *) comp->c_tws, 0, sizeof *comp->c_tws);
+               ZERO(comp->c_tws);
                comp->c_flags = CF_TRUE;
            }
            comp->c_flags |= CF_PARSED;
                comp->c_flags = CF_TRUE;
            }
            comp->c_flags |= CF_PARSED;
@@ -995,16 +1045,17 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
 
            lp = str;
            wid = value;
 
            lp = str;
            wid = value;
-           len = strlen (str);
+           len = str ? strlen (str) : 0;
            sp = fmt->f_text;
            indent = strlen (sp);
            wid -= indent;
            if (wid <= 0) {
            sp = fmt->f_text;
            indent = strlen (sp);
            wid -= indent;
            if (wid <= 0) {
-               adios(NULL, "putaddr -- num register (%d) must be greater "
+               die("putaddr -- num register (%d) must be greater "
                            "than label width (%d)", value, indent);
            }
                            "than label width (%d)", value, indent);
            }
-           while( (c = (unsigned char) *sp++) && cp < ep)
-               *cp++ = (char) c;
+           while ((c = *sp++) && charstring_chars (scanlp) < max) {
+               charstring_push_back (scanlp, c);
+           }
            while (len > wid) {
                /* try to break at a comma; failing that, break at a
                 * space.
            while (len > wid) {
                /* try to break at a comma; failing that, break at a
                 * space.
@@ -1025,18 +1076,22 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
                    }
                }
                len -= sp - lp + 1;
                    }
                }
                len -= sp - lp + 1;
-               while (cp < ep && lp <= sp)
-                   *cp++ = *lp++;
+               while (lp <= sp && charstring_chars (scanlp) < max) {
+                   charstring_push_back (scanlp, *lp++);
+               }
                while (isspace((unsigned char) *lp))
                    lp++, len--;
                if (*lp) {
                while (isspace((unsigned char) *lp))
                    lp++, len--;
                if (*lp) {
-                   if (cp < ep)
-                       *cp++ = '\n';
-                   for (i=indent; cp < ep && i > 0; i--)
-                       *cp++ = ' ';
+                   if (charstring_chars (scanlp) < max) {
+                       charstring_push_back (scanlp, '\n');
+                    }
+                   for (i=indent;
+                        charstring_chars (scanlp) < max && i > 0;
+                        i--)
+                       charstring_push_back (scanlp, ' ');
                }
            }
                }
            }
-           cpstripped (&cp, &ep, scanl + max - 1, lp);
+           cpstripped (scanlp, max - charstring_chars (scanlp), lp);
            }
            break;
 
            }
            break;
 
@@ -1060,6 +1115,8 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            break;
 
        case FT_MYMBOX:
            break;
 
        case FT_MYMBOX:
+       case FT_GETMYMBOX:
+       case FT_GETMYADDR:
            /*
             * if there's no component, we say true.  Otherwise we
             * say "true" only if we can parse the address and it
            /*
             * if there's no component, we say true.  Otherwise we
             * say "true" only if we can parse the address and it
@@ -1071,24 +1128,50 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            if ((sp = comp->c_text) && (sp = getname(sp)) &&
                (mn = getm (sp, NULL, 0, NULL, 0))) {
                comp->c_mn = mn;
            if ((sp = comp->c_text) && (sp = getname(sp)) &&
                (mn = getm (sp, NULL, 0, NULL, 0))) {
                comp->c_mn = mn;
-               if (ismymbox(mn))
+               if (ismymbox(mn)) {
                    comp->c_flags |= CF_TRUE;
                    comp->c_flags |= CF_TRUE;
-               else
+                   /* Set str for use with FT_GETMYMBOX.  With
+                      FT_GETMYADDR, comp->c_mn will be run through
+                      FT_LS_ADDR, which will strip off any pers
+                      name. */
+                   str = mn->m_text;
+               } else {
                    comp->c_flags &= ~CF_TRUE;
                    comp->c_flags &= ~CF_TRUE;
+               }
                while ((sp = getname(sp)))
                    if ((comp->c_flags & CF_TRUE) == 0 &&
                        (mn = getm (sp, NULL, 0, NULL, 0)))
                while ((sp = getname(sp)))
                    if ((comp->c_flags & CF_TRUE) == 0 &&
                        (mn = getm (sp, NULL, 0, NULL, 0)))
-                       if (ismymbox(mn))
+                       if (ismymbox(mn)) {
                            comp->c_flags |= CF_TRUE;
                            comp->c_flags |= CF_TRUE;
+                           /* Set str and comp->c_text for use with
+                              FT_GETMYMBOX.  With FT_GETMYADDR,
+                              comp->c_mn will be run through
+                              FT_LS_ADDR, which will strip off any
+                              pers name. */
+                           /* NB: We remove the call to free() here
+                              because it interferes with the buffer
+                              management in scansbr.c.  Revisit this
+                              when we clean up memory handling */
+                           /* free (comp->c_text); */
+                           comp->c_text = str = strdup (mn->m_text);
+                           comp->c_mn = mn;
+                       }
+               comp->c_flags |= CF_PARSED;
            } else {
                while (getname(""))             /* XXX */
                    ;
                if (comp->c_text == 0)
                    comp->c_flags |= CF_TRUE;
            } else {
                while (getname(""))             /* XXX */
                    ;
                if (comp->c_text == 0)
                    comp->c_flags |= CF_TRUE;
-               else
+               else {
                    comp->c_flags &= ~CF_TRUE;
                    comp->c_flags &= ~CF_TRUE;
+               }
                comp->c_mn = &fmt_mnull;
            }
                comp->c_mn = &fmt_mnull;
            }
+           if ((comp->c_flags & CF_TRUE) == 0  &&
+               (fmt->f_type == FT_GETMYMBOX || fmt->f_type == FT_GETMYADDR)) {
+               /* Fool FT_LS_ADDR into not producing an address. */
+               comp->c_mn = &fmt_mnull; comp->c_text = NULL;
+           }
            break;
        }
 
            break;
        }
 
@@ -1098,7 +1181,7 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
 
        if (callbacks && callbacks->trace_func)
            callbacks->trace_func(callbacks->trace_context, fmt, value,
 
        if (callbacks && callbacks->trace_func)
            callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                 str, scanl);
+                                 str, charstring_buffer (scanlp));
        fmt++;
     }
 
        fmt++;
     }
 
@@ -1108,30 +1191,45 @@ fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat,
            str = fmt->f_text;
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
            str = fmt->f_text;
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                     str, scanl);
+                                     str, charstring_buffer (scanlp));
        } else if (fmt->f_type == FT_STRLITZ) {
            /* Don't want to emit part of an escape sequence.  So if
               there isn't enough room in the buffer for the entire
               string, skip it completely.  Need room for null
               terminator, and maybe trailing newline (added below). */
        } else if (fmt->f_type == FT_STRLITZ) {
            /* Don't want to emit part of an escape sequence.  So if
               there isn't enough room in the buffer for the entire
               string, skip it completely.  Need room for null
               terminator, and maybe trailing newline (added below). */
-           if (str && (cp - scanl + strlen (str) + 1 < max)) {
-               for (sp = str; *sp; *cp++ = *sp++) continue;
+           if (str) {
+               for (sp = str; *sp; ++sp) {
+                   charstring_push_back (scanlp, *sp);
+               }
            }
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
            }
            if (callbacks && callbacks->trace_func)
                callbacks->trace_func(callbacks->trace_context, fmt, value,
-                                     str, scanl);
+                                     str, charstring_buffer (scanlp));
        }
        fmt++;
     }
 
        }
        fmt++;
     }
 
-    finished:;
-    if (cp > scanl  &&  cp[-1] != '\n') {
-       if (cp - scanl < (int) max - 1) {
-           *cp++ = '\n';
-       } else {
-           cp[-1] = '\n';
+    finished:
+    if (charstring_bytes (scanlp) > 0) {
+       /*
+        * Append a newline if the last character wasn't.
+        */
+#ifdef MULTIBYTE_SUPPORT
+       /*
+        * It's a little tricky because the last byte might be part of
+        * a multibyte character, in which case we assume that wasn't
+        * a newline.
+        */
+       size_t last_char_len = charstring_last_char_len (scanlp);
+#else  /* ! MULTIBYTE_SUPPORT */
+       size_t last_char_len = 1;
+#endif /* ! MULTIBYTE_SUPPORT */
+
+       if (last_char_len > 1  ||
+           charstring_buffer (scanlp)[charstring_bytes (scanlp) - 1] != '\n') {
+           charstring_push_back (scanlp, '\n');
        }
     }
        }
     }
-    *cp = '\0';
-    return ((struct format *)0);
+
+    return NULL;
 }
 }
Fork of https://git.savannah.nongnu.org/cgit/nmh.git