small reorg.
[apps/madmutt.git] / muttlib.c
index 1f8ab30..57fabf3 100644 (file)
--- a/muttlib.c
+++ b/muttlib.c
 #include <grp.h>
 #include <pwd.h>
 
-#include <lib-mime/mime.h>
 #include <lib-ui/curses.h>
 #include <lib-ui/enter.h>
 #include <lib-sys/unix.h>
-#include <lib-mx/mx.h>
+#include <imap/imap.h>
 
 #include "alias.h"
 #include "mutt.h"
 #include "attach.h"
-
 #include "version.h"
 
-#include <imap/imap.h>
-
-#include <lib-crypt/crypt.h>
-
-#define SW              (option(OPTMBOXPANE)?SidebarWidth:0)
-
 /* Modified by blong to accept a "suggestion" for file name.  If
  * that file exists, then construct one with unique name but 
  * keep any extension.  This might fail, I guess.
@@ -50,15 +42,15 @@ void mutt_adv_mktemp (const char* dir, char *s, ssize_t l)
     }
 }
 
-/* returns true if the header contained in "s" is in list "t" */
-int mutt_matches_ignore (const char *s, string_list_t * t)
+void mutt_mktemp(char *s)
 {
-  for (; t; t = t->next) {
-    if (!ascii_strncasecmp (s, t->data, m_strlen(t->data))
-        || *t->data == '*')
-      return 1;
-  }
-  return 0;
+    int fd = m_tempfd(s, _POSIX_PATH_MAX, NONULL(Tempdir), NULL);
+    if (fd < 0) {
+        *s = '\0';
+    } else {
+        close(fd);
+        unlink(s);
+    }
 }
 
 ssize_t _mutt_expand_path(char *s, ssize_t slen, int rx)
@@ -170,17 +162,6 @@ ssize_t _mutt_expand_path(char *s, ssize_t slen, int rx)
     return m_strcpy(s, slen, tmp);
 }
 
-void mutt_mktemp(char *s)
-{
-    int fd = m_tempfd(s, _POSIX_PATH_MAX, NONULL(Tempdir), NULL);
-    if (fd < 0) {
-        *s = '\0';
-    } else {
-        close(fd);
-        unlink(s);
-    }
-}
-
 /* collapse the pathname using ~ or = when possible */
 void mutt_pretty_mailbox (char *s)
 {
@@ -328,211 +309,6 @@ void mutt_safe_path(char *s, ssize_t l, address_t *a)
     }
 }
 
-void mutt_FormatString (char *dest,     /* output buffer */
-                        ssize_t destlen, /* output buffer len */
-                        const char *src,        /* template string */
-                        format_t * callback,    /* callback for processing */
-                        unsigned long data,     /* callback data */
-                        format_flag flags)
-{                               /* callback flags */
-  char prefix[STRING], buf[LONG_STRING], *cp, *wptr = dest, ch;
-  char ifstring[STRING], elsestring[STRING];
-  ssize_t wlen, wid, count, col, len;
-
-  prefix[0] = '\0';
-  destlen--;                    /* save room for the terminal \0 */
-  wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
-  col = wlen;
-
-  while (*src && wlen < destlen) {
-    if (*src == '%') {
-      if (*++src == '%') {
-        *wptr++ = '%';
-        wlen++;
-        col++;
-        src++;
-        continue;
-      }
-
-      if (*src == '?') {
-        flags |= M_FORMAT_OPTIONAL;
-        src++;
-      }
-      else {
-        flags &= ~M_FORMAT_OPTIONAL;
-
-        /* eat the format string */
-        cp = prefix;
-        count = 0;
-        while (count < ssizeof (prefix) &&
-               (isdigit ((unsigned char) *src) || *src == '.' || *src == '-'))
-        {
-          *cp++ = *src++;
-          count++;
-        }
-        *cp = 0;
-      }
-
-      if (!*src)
-        break;                  /* bad format */
-
-      ch = *src++;              /* save the character to switch on */
-
-      if (flags & M_FORMAT_OPTIONAL) {
-        if (*src != '?')
-          break;                /* bad format */
-        src++;
-
-        /* eat the `if' part of the string */
-        cp = ifstring;
-        count = 0;
-        while (count < ssizeof (ifstring) && *src && *src != '?'
-               && *src != '&') {
-          *cp++ = *src++;
-          count++;
-        }
-        *cp = 0;
-
-        /* eat the `else' part of the string (optional) */
-        if (*src == '&')
-          src++;                /* skip the & */
-        cp = elsestring;
-        count = 0;
-        while (count < ssizeof (elsestring) && *src && *src != '?') {
-          *cp++ = *src++;
-          count++;
-        }
-        *cp = 0;
-
-        if (!*src)
-          break;                /* bad format */
-
-        src++;                  /* move past the trailing `?' */
-      }
-
-      /* handle generic cases first */
-      if (ch == '>') {
-        /* right justify to EOL */
-        ch = *src++;            /* pad char */
-        /* calculate space left on line.  if we've already written more data
-           than will fit on the line, ignore the rest of the line */
-        if (DrawFullLine || option (OPTSTATUSONTOP))
-          count = (COLS < destlen ? COLS : destlen);
-        else
-          count = ((COLS - SW) < destlen ? (COLS - SW) : destlen);
-        if (count > col) {
-          count -= col;         /* how many columns left on this line */
-          mutt_FormatString (buf, sizeof (buf), src, callback, data, flags);
-          wid = m_strlen(buf);
-          if (count > wid) {
-            count -= wid;       /* how many chars to pad */
-            memset (wptr, ch, count);
-            wptr += count;
-            col += count;
-          }
-          if (wid + wlen > destlen)
-            len = destlen - wlen;
-          else
-            len = wid;
-          memcpy (wptr, buf, len);
-          wptr += len;
-          wlen += len;
-          col += mutt_strwidth (buf);
-        }
-        break;                  /* skip rest of input */
-      }
-      else if (ch == '|') {
-        /* pad to EOL */
-        ch = *src++;
-        if (destlen > COLS)
-          destlen = COLS;
-        if (destlen > wlen) {
-          count = destlen - wlen;
-          memset (wptr, ch, count);
-          wptr += count;
-        }
-        break;                  /* skip rest of input */
-      }
-      else {
-        short lower = 0;
-        short nodots = 0;
-
-        while (ch == '_' || ch == ':') {
-          if (ch == '_')
-            lower = 1;
-          else if (ch == ':')
-            nodots = 1;
-
-          ch = *src++;
-        }
-
-        /* use callback function to handle this case */
-        src =
-          callback (buf, sizeof (buf), ch, src, prefix, ifstring, elsestring,
-                    data, flags);
-
-        if (lower)
-          m_strtolower(buf);
-        if (nodots) {
-          char *p = buf;
-
-          for (; *p; p++)
-            if (*p == '.')
-              *p = '_';
-        }
-
-        if ((len = m_strlen(buf)) + wlen > destlen)
-          len = (destlen - wlen > 0) ? (destlen - wlen) : 0;
-
-        memcpy (wptr, buf, len);
-        wptr += len;
-        wlen += len;
-        col += mutt_strwidth (buf);
-      }
-    }
-    else if (*src == '\\') {
-      if (!*++src)
-        break;
-      switch (*src) {
-      case 'n':
-        *wptr = '\n';
-        break;
-      case 't':
-        *wptr = '\t';
-        break;
-      case 'r':
-        *wptr = '\r';
-        break;
-      case 'f':
-        *wptr = '\f';
-        break;
-      case 'v':
-        *wptr = '\v';
-        break;
-      default:
-        *wptr = *src;
-        break;
-      }
-      src++;
-      wptr++;
-      wlen++;
-      col++;
-    }
-    else {
-      unsigned int bar = strcspn(src, "%\\");
-      char *bar2 = p_dupstr(src, bar);
-
-      while (bar--) {
-        *wptr++ = *src++;
-        wlen++;
-      }
-      col += mutt_strwidth (bar2);
-      p_delete(&bar2);
-    }
-  }
-  *wptr = 0;
-}
-
 /* returns 0 if OK to proceed, -1 to abort, 1 to retry */
 int mutt_save_confirm (const char *s, struct stat *st)
 {
@@ -750,7 +526,7 @@ int mutt_extract_token(BUFFER *dest, BUFFER *tok, int flags)
                 if (!*tok->dptr)
                     return -1;          /* premature end of token */
                 mutt_buffer_addch(dest,
-                                  (ascii_toupper(*tok->dptr) - 'A' + 1) & 0x7f);
+                                  (toupper((unsigned char)*tok->dptr) - 'A' + 1) & 0x7f);
                 tok->dptr++;
                 break;
               case 'r':
@@ -792,7 +568,7 @@ int mutt_extract_token(BUFFER *dest, BUFFER *tok, int flags)
                 mutt_buffer_addch(dest, '\033');
             } else
             if (isalpha((unsigned char)ch)) {
-                mutt_buffer_addch(dest, ascii_toupper(ch) - 'A' + 1);
+                mutt_buffer_addch(dest, toupper((unsigned char)ch) - 'A' + 1);
             } else {
                 mutt_buffer_addch(dest, '^');
                 mutt_buffer_addch(dest, ch);