Create a dependency for mh-chart.man on all of the man page sources so

[nmh] / sbr / fmt_scan.c

diff --git a/sbr/fmt_scan.c b/sbr/fmt_scan.c
index ca4020b073af9354ebb79d508f6c94a2817ff683..0d9e1e90de8b8c3c7324ba7f12f38c7261b92dc2 100644 (file)
--- a/sbr/fmt_scan.c
+++ b/sbr/fmt_scan.c
@@ -2,11 +2,12 @@
 /*
  * fmt_scan.c -- format string interpretation
  *
 /*
  * fmt_scan.c -- format string interpretation
  *

- * $Id$
- *

  * This code is Copyright (c) 2002, by the authors of nmh.  See the
  * COPYRIGHT file in the root directory of the nmh distribution for
  * complete copyright information.
  * This code is Copyright (c) 2002, by the authors of nmh.  See the
  * COPYRIGHT file in the root directory of the nmh distribution for
  * complete copyright information.

+ *
+ * This is the engine that processes the format instructions created by
+ * fmt_compile (found in fmt_compile.c).

  */
 
 #include <h/mh.h>
  */
 
 #include <h/mh.h>


@@ -15,31 +16,22 @@
 #include <h/tws.h>
 #include <h/fmt_compile.h>
 
 #include <h/tws.h>
 #include <h/fmt_compile.h>
 

-#ifdef TIME_WITH_SYS_TIME
+#ifdef HAVE_SYS_TIME_H

 # include <sys/time.h>
 # include <sys/time.h>

-# include <time.h>
-#else
-# ifdef TM_IN_SYS_TIME
-#  include <sys/time.h>
-# else
-#  include <time.h>
-# endif

 #endif
 #endif

+#include <time.h>

 #ifdef MULTIBYTE_SUPPORT
 #  include <wctype.h>
 #  include <wchar.h>
 #endif
 
 #ifdef MULTIBYTE_SUPPORT
 #  include <wctype.h>
 #  include <wchar.h>
 #endif
 

-#define        NFMTS MAXARGS
-
-extern char *formataddr ();    /* hook for custom address formatting */
-

 #ifdef LBL
 struct msgs *fmt_current_folder; /* current folder (set by main program) */
 #endif
 
 extern int fmt_norm;           /* defined in sbr/fmt_def.c = AD_NAME */
 #ifdef LBL
 struct msgs *fmt_current_folder; /* current folder (set by main program) */
 #endif
 
 extern int fmt_norm;           /* defined in sbr/fmt_def.c = AD_NAME */

-struct mailname fmt_mnull;
+struct mailname fmt_mnull = { NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0, 0,
+                             NULL, NULL };

 
 /*
  * static prototypes
 
 /*
  * static prototypes


@@ -126,17 +118,20 @@ cpnumber(char **dest, int num, unsigned int wid, char fill, size_t n) {
  * no more than n bytes are copied
  */
 static void
  * no more than n bytes are copied
  */
 static void

-cptrimmed(char **dest, char *str, unsigned int wid, char fill, size_t n) {
+cptrimmed(char **dest, char *str, unsigned int wid, char fill, size_t n,
+         size_t max) {

     int remaining;     /* remaining output width available */
     int remaining;     /* remaining output width available */

-    int c, ljust, w;
+    int c, ljust;

     int end;           /* number of input bytes remaining in str */
 #ifdef MULTIBYTE_SUPPORT
     int char_len;      /* bytes in current character */
     int end;           /* number of input bytes remaining in str */
 #ifdef MULTIBYTE_SUPPORT
     int char_len;      /* bytes in current character */

+    int w;

     wchar_t wide_char;
 #endif
     char *sp;          /* current position in source string */
     char *cp = *dest;  /* current position in destination string */
     wchar_t wide_char;
 #endif
     char *sp;          /* current position in source string */
     char *cp = *dest;  /* current position in destination string */

-    char *ep = cp + n; /* end of destination buffer */
+    char *ep = cp + n; /* end of destination buffer based on desired width */
+    char *epmax = cp + max; /* true end of destination buffer */

     int prevCtrl = 1;
 
     /* get alignment */
     int prevCtrl = 1;
 
     /* get alignment */


@@ -151,6 +146,13 @@ cptrimmed(char **dest, char *str, unsigned int wid, char fill, size_t n) {
        while (*sp && remaining > 0 && end > 0) {
 #ifdef MULTIBYTE_SUPPORT
            char_len = mbtowc(&wide_char, sp, end);
        while (*sp && remaining > 0 && end > 0) {
 #ifdef MULTIBYTE_SUPPORT
            char_len = mbtowc(&wide_char, sp, end);

+
+           /* Account for multibyte characters taking only one character's
+              width of output. */
+           if (char_len > 1  &&  epmax - ep >= char_len - 1) {
+               ep += char_len - 1;
+           }
+

            if (char_len <= 0 || (cp + char_len > ep))
                break;
 
            if (char_len <= 0 || (cp + char_len > ep))
                break;
 


@@ -159,8 +161,12 @@ cptrimmed(char **dest, char *str, unsigned int wid, char fill, size_t n) {
            if (iswcntrl(wide_char) || iswspace(wide_char)) {
                sp += char_len;
 #else
            if (iswcntrl(wide_char) || iswspace(wide_char)) {
                sp += char_len;
 #else

+            int c;

            end--;
            end--;

-           if (iscntrl(*sp) || isspace(*sp)) {
+            /* isnctrl(), etc., take an int argument.  Cygwin's ctype.h
+               intentionally warns if they are passed a char. */
+            c = *sp;
+           if (iscntrl(c) || isspace(c)) {

                sp++;
 #endif
                if (!prevCtrl) {
                sp++;
 #endif
                if (!prevCtrl) {


@@ -211,37 +217,70 @@ cptrimmed(char **dest, char *str, unsigned int wid, char fill, size_t n) {
 }
 
 static void
 }
 
 static void

-cpstripped (char **start, char *end, char *str)
+cpstripped (char **dest, char *end, char *max, char *str)

 {
 {

-    int c;
-    char *s = str;
+    int prevCtrl = 1;  /* This is 1 so we strip out leading spaces */
+    int len;
+#ifdef MULTIBYTE_SUPPORT
+    int char_len;
+    wchar_t wide_char;
+#endif /* MULTIBYTE_SUPPORT */

 
 

-    if (!s)
+    if (!str)

        return;
 
        return;
 

-    /* skip any initial control characters or spaces */
-    while ((c = (unsigned char) *s) &&
-#ifdef LOCALE
-           (iscntrl(c) || isspace(c)))
-#else
-           (c <= 32))
-#endif
-       s++;
-
-    /* compact repeated control characters and spaces into a single space */
-    while((c = (unsigned char) *s++) && *start < end)
-       if (!iscntrl(c) && !isspace(c))
-           *(*start)++ = c;
-       else {
-           while ((c = (unsigned char) *s) &&
-#ifdef LOCALE
-                   (iscntrl(c) || isspace(c)))
-#else
-                   (c <= 32))
-#endif
-               s++;
-           *(*start)++ = ' ';
+    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);
+
+       /* Account for multibyte characters taking only one character's
+          width of output. */
+       if (char_len > 1  &&  max - end >= char_len - 1) {
+           end += char_len - 1;

        }
        }

+
+       if (char_len <= 0 || *dest + char_len > end)
+           break;
+
+       len -= char_len;
+
+       if (iswcntrl(wide_char) || iswspace(wide_char)) {
+           str += char_len;
+#else /* MULTIBYTE_SUPPORT */
+       int c = *str;
+       len--;
+       if (iscntrl(c) || isspace(c)) {
+           str++;
+#endif /* MULTIBYTE_SUPPORT */
+           if (! prevCtrl) {
+               *(*dest)++ = ' ';
+           }
+
+           prevCtrl = 1;
+           continue;
+       }
+
+       prevCtrl = 0;
+
+#ifdef MULTIBYTE_SUPPORT
+       memcpy(*dest, str, char_len);
+       str += char_len;
+       *dest += char_len;
+#else /* MULTIBYE_SUPPORT */
+       *(*dest)++ = *str++
+#endif /* MULTIBYTE_SUPPORT */
+    }

 }
 
 static char *lmonth[] = { "January",  "February","March",   "April",
 }
 
 static char *lmonth[] = { "January",  "February","March",   "April",


@@ -293,11 +332,11 @@ get_x400_comp (char *mbox, char *key, char *buffer, int buffer_len)
 }
 
 struct format *
 }
 
 struct format *

-fmt_scan (struct format *format, char *scanl, int width, int *dat)
+fmt_scan (struct format *format, char *scanl, size_t max, int width, int *dat)

 {
     char *cp, *ep;
     unsigned char *sp;
 {
     char *cp, *ep;
     unsigned char *sp;

-    char *savestr;
+    char *savestr = NULL;

     unsigned char *str = NULL;
     char buffer[BUFSIZ], buffer2[BUFSIZ];
     int i, c, ljust, n;
     unsigned char *str = NULL;
     char buffer[BUFSIZ], buffer2[BUFSIZ];
     int i, c, ljust, n;


@@ -308,8 +347,11 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
     struct tws *tws;
     struct mailname *mn;
 
     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;
     cp = scanl;

-    ep = scanl + width - 1;
+    ep = scanl + (width <= (int) max ? width : (int) max) - 1;

 
     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) {


@@ -317,6 +359,27 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
        case FT_PARSEDATE:
            fmt->f_comp->c_flags &= ~CF_PARSED;
            break;
        case FT_PARSEDATE:
            fmt->f_comp->c_flags &= ~CF_PARSED;
            break;

+       case FT_COMP:
+       case FT_COMPF:
+       case FT_LS_COMP:
+       case FT_LS_DECODECOMP:
+           /*
+            * Trim these components of any newlines.
+            *
+            * But don't trim the "body" and "text" components.
+            */
+
+           comp = fmt->f_comp;
+
+           if (! (comp->c_flags & CF_TRIMMED) && comp->c_text) {
+               i = strlen(comp->c_text);
+               if (comp->c_text[i - 1] == '\n' &&
+                       strcmp(comp->c_name, "body") != 0 &&
+                       strcmp(comp->c_name, "text") != 0)
+                   comp->c_text[i - 1] = '\0';
+               comp->c_flags |= CF_TRIMMED;
+           }
+           break;

        }
 
     fmt = format;
        }
 
     fmt = format;


@@ -325,10 +388,11 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
        switch (fmt->f_type) {
 
        case FT_COMP:
        switch (fmt->f_type) {
 
        case FT_COMP:

-           cpstripped (&cp, ep, fmt->f_comp->c_text);
+           cpstripped (&cp, ep, scanl + max - 1, fmt->f_comp->c_text);

            break;
        case FT_COMPF:
            break;
        case FT_COMPF:

-           cptrimmed (&cp, fmt->f_comp->c_text, fmt->f_width, fmt->f_fill, ep - cp);
+           cptrimmed (&cp, fmt->f_comp->c_text, fmt->f_width, fmt->f_fill,
+                      ep - cp, scanl - cp + max - 1);

            break;
 
        case FT_LIT:
            break;
 
        case FT_LIT:


@@ -351,11 +415,36 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
            break;
 
        case FT_STR:
            break;
 
        case FT_STR:

-           cpstripped (&cp, ep, str);
+           cpstripped (&cp, ep, scanl + max - 1, str);

            break;
        case FT_STRF:
            break;
        case FT_STRF:

-           cptrimmed (&cp, str, fmt->f_width, fmt->f_fill, ep - cp);
+           cptrimmed (&cp, str, fmt->f_width, fmt->f_fill, ep - cp,
+                      scanl - cp + max - 1);
+           break;
+       case FT_STRLIT:
+           sp = str;
+           while ((c = *sp++) && cp < ep)
+               *cp++ = c;
+           break;
+       case FT_STRLITZ: {
+           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;
+               }
+           }
+

            break;
            break;

+       }

        case FT_STRFW:
            adios (NULL, "internal error (FT_STRFW)");
 
        case FT_STRFW:
            adios (NULL, "internal error (FT_STRFW)");
 


@@ -508,13 +597,13 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                            ljust++;
                    }
 
                            ljust++;
                    }
 

-                   if (!ljust && i > 0 && strlen(str) > i)
+                   if (!ljust && i > 0 && (int) strlen(str) > i)

                            str[i] = '\0';
                    xp = str;
                    xp += strlen(str) - 1;
                    while (xp > str && isspace(*xp))
                            *xp-- = '\0';
                            str[i] = '\0';
                    xp = str;
                    xp += strlen(str) - 1;
                    while (xp > str && isspace(*xp))
                            *xp-- = '\0';

-                   if (ljust && i > 0 && strlen(str) > i)
+                   if (ljust && i > 0 && (int) strlen(str) > i)

                        str += strlen(str) - i;
            }
            break;
                        str += strlen(str) - i;
            }
            break;


@@ -795,6 +884,11 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
            str = formataddr (savestr, str);
            break;
 
            str = formataddr (savestr, str);
            break;
 

+       case FT_CONCATADDR:
+           /* The same as formataddr, but doesn't do duplicate suppression */
+           str = concataddr (savestr, str);
+           break;
+

        case FT_PUTADDR:
            /* output the str register as an address component,
             * splitting it into multiple lines if necessary.  The
        case FT_PUTADDR:
            /* output the str register as an address component,
             * splitting it into multiple lines if necessary.  The


@@ -813,6 +907,10 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
            sp = fmt->f_text;
            indent = strlen (sp);
            wid -= indent;
            sp = fmt->f_text;
            indent = strlen (sp);
            wid -= indent;

+           if (wid <= 0) {
+               adios(NULL, "putaddr -- num register (%d) must be greater "
+                           "than label width (%d)", value, indent);
+           }

            while( (c = *sp++) && cp < ep)
                *cp++ = c;
            while (len > wid) {
            while( (c = *sp++) && cp < ep)
                *cp++ = c;
            while (len > wid) {


@@ -845,7 +943,7 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
                        *cp++ = ' ';
                }
            }
                        *cp++ = ' ';
                }
            }

-           cpstripped (&cp, ep, lp);
+           cpstripped (&cp, ep, scanl + max - 1, lp);

            }
            break;
 
            }
            break;
 


@@ -913,21 +1011,31 @@ fmt_scan (struct format *format, char *scanl, int width, int *dat)
        }
        fmt++;
     }
        }
        fmt++;
     }

-#ifndef JLR
-    finished:;
-    if (cp[-1] != '\n')
-       *cp++ = '\n';
-    *cp   = 0;
-    return ((struct format *)0);
-#else /* JLR */
-    if (cp[-1] != '\n')
-       *cp++ = '\n';
-    while (fmt->f_type != FT_DONE)
+
+    /* Emit any trailing sequences of zero display length. */
+    while (fmt->f_type != FT_DONE) {
+       if (fmt->f_type == FT_LS_LIT) {
+           str = fmt->f_text;
+       } 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 (cp - scanl + strlen (str) + 1 < max) {
+               for (sp = str; *sp; *cp++ = *sp++) continue;
+           }
+       }

        fmt++;
        fmt++;

+    }

 
     finished:;
 
     finished:;

+    if (cp > scanl  &&  cp[-1] != '\n') {
+       if (cp - scanl < (int) max - 1) {
+           *cp++ = '\n';
+       } else {
+           cp[-1] = '\n';
+       }
+    }

     *cp = '\0';
     *cp = '\0';

-    return (fmt->f_value ? ++fmt : (struct format *) 0);
-
-#endif /* JLR */
+    return ((struct format *)0);

 }
 }