Expando API

Prototype for a mutt_expando_format() Callback Function. More...

Functions
static const char *	alias_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the alias list - Implements format_t -.
static const char *	query_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the query menu - Implements format_t -.
const char *	attach_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the attachment menu - Implements format_t -.
static const char *	autocrypt_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the Autocrypt account list - Implements format_t -.
static const char *	folder_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the folder browser - Implements format_t -.
static const char *	compress_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Expand the filenames in a command string - Implements format_t -.
static const char *	compose_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Create the status bar string for compose mode - Implements format_t -.
static const char *	index_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the index list - Implements format_t -.
static const char *	history_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the history list - Implements format_t -.
static const char *	mix_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the remailer menu - Implements format_t -.
void	mutt_expando_format (char *buf, size_t buflen, size_t col, int cols, const char *src, format_t callback, intptr_t data, MuttFormatFlags flags)
	Expand expandos (x) in a string -.
static const char *	crypt_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the key selection menu - Implements format_t -.
static const char *	pgp_entry_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format an entry on the PGP key selection menu - Implements format_t -.
static const char *	pgp_command_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a PGP command string - Implements format_t -.
static const char *	smime_command_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format an SMIME command - Implements format_t -.
const char *	group_index_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the newsgroup menu - Implements format_t -.
const char *	nntp_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Expand the newsrc filename - Implements format_t -.
static const char *	pattern_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the pattern completion menu - Implements format_t -.
static const char *	greeting_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a greetings string - Implements format_t -.
static const char *	sidebar_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Format a string for the sidebar - Implements format_t -.
static const char *	status_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Create the status bar string - Implements format_t -.

Detailed Description

Prototype for a mutt_expando_format() Callback Function.

Parameters

[out]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[in]	col	Starting column
[in]	cols	Number of screen columns
[in]	op	printf-like operator, e.g. 't'
[in]	src	printf-like format string
[in]	prec	Field precision, e.g. "-3.4"
[in]	if_str	If condition is met, display this string
[in]	else_str	Otherwise, display this string
[in]	data	Private data
[in]	flags	Flags, see MuttFormatFlags

Return values

ptr	src (unchanged)

Each callback function implements some expandos, e.g.

Expando	Description
%t	Title

Function Documentation

alias_format_str()

static const char * alias_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the alias list - Implements format_t -.

Expando	Description
%a	Alias name
%c	Comments
%f	Flags - currently, a 'd' for an alias marked for deletion
%n	Index number
%r	Address which alias expands to
%t	Character which indicates if the alias is tagged for inclusion

Definition at line 122 of file dlg_alias.c.

{
  char tmp[1024];
  struct AliasView *av = (struct AliasView *) data;
  struct Alias *alias = av->alias;
 
  switch (op)
  {
    case 'a':
      mutt_format_s(buf, buflen, prec, alias->name);
      break;
    case 'c':
      mutt_format_s(buf, buflen, prec, alias->comment);
      break;
    case 'f':
      snprintf(tmp, sizeof(tmp), "%%%ss", prec);
      snprintf(buf, buflen, tmp, av->is_deleted ? "D" : " ");
      break;
    case 'n':
      snprintf(tmp, sizeof(tmp), "%%%sd", prec);
      snprintf(buf, buflen, tmp, av->num + 1);
      break;
    case 'r':
    {
      struct Buffer *tmpbuf = buf_pool_get();
      mutt_addrlist_write(&alias->addr, tmpbuf, true);
      mutt_str_copy(tmp, buf_string(tmpbuf), sizeof(tmp));
      buf_pool_release(&tmpbuf);
      mutt_format_s(buf, buflen, prec, tmp);
      break;
    }
    case 't':
      buf[0] = av->is_tagged ? '*' : ' ';
      buf[1] = '\0';
      break;
  }
 
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

query_format_str()

static const char * query_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the query menu - Implements format_t -.

Expando	Description
%a	Destination address
%c	Current entry number
%e	Extra information
%n	Destination name
%t	* if current entry is tagged, a space otherwise

Definition at line 152 of file dlg_query.c.

{
  struct AliasView *av = (struct AliasView *) data;
  struct Alias *alias = av->alias;
  char fmt[128] = { 0 };
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'a':
    {
      struct Buffer *tmpbuf = buf_pool_get();
      char tmp[256] = { 0 };
      tmp[0] = '<';
      mutt_addrlist_write(&alias->addr, tmpbuf, true);
      mutt_str_copy(tmp + 1, buf_string(tmpbuf), sizeof(tmp) - 1);
      buf_pool_release(&tmpbuf);
      const size_t len = strlen(tmp);
      if (len < (sizeof(tmp) - 1))
      {
        tmp[len] = '>';
        tmp[len + 1] = '\0';
      }
      mutt_format_s(buf, buflen, prec, tmp);
      break;
    }
    case 'c':
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      snprintf(buf, buflen, fmt, av->num + 1);
      break;
    case 'e':
      if (!optional)
        mutt_format_s(buf, buflen, prec, NONULL(alias->comment));
      else if (!alias->comment || (*alias->comment == '\0'))
        optional = false;
      break;
    case 'n':
      mutt_format_s(buf, buflen, prec, NONULL(alias->name));
      break;
    case 't':
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      snprintf(buf, buflen, fmt, av->is_tagged ? '*' : ' ');
      break;
    default:
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      snprintf(buf, buflen, fmt, op);
      break;
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, query_format_str, data,
                        MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, query_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

attach_format_str()

const char * attach_format_str	(	char *	buf,
		size_t	buflen,
		size_t	col,
		int	cols,
		char	op,
		const char *	src,
		const char *	prec,
		const char *	if_str,
		const char *	else_str,
		intptr_t	data,
		MuttFormatFlags	flags
	)

Format a string for the attachment menu - Implements format_t -.

Expando	Description
%C	Character set
%c	Character set: convert?
%D	Deleted flag
%d	Description
%e	MIME content-transfer-encoding
%f	Filename
%F	Filename for content-disposition header
%I	Content-disposition, either I (inline) or A (attachment)
%m	Major MIME type
%M	MIME subtype
%n	Attachment number
%Q	'Q', if MIME part qualifies for attachment counting
%s	Size
%t	Tagged flag
%T	Tree chars
%u	Unlink
%X	Number of qualifying MIME parts in this part and its children

Definition at line 151 of file dlg_attach.c.

{
  char fmt[128] = { 0 };
  char charset[128] = { 0 };
  struct AttachPtr *aptr = (struct AttachPtr *) data;
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'C':
      if (!optional)
      {
        if (mutt_is_text_part(aptr->body) &&
            mutt_body_get_charset(aptr->body, charset, sizeof(charset)))
        {
          mutt_format_s(buf, buflen, prec, charset);
        }
        else
        {
          mutt_format_s(buf, buflen, prec, "");
        }
      }
      else if (!mutt_is_text_part(aptr->body) ||
               !mutt_body_get_charset(aptr->body, charset, sizeof(charset)))
      {
        optional = false;
      }
      break;
    case 'c':
      /* XXX */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
        snprintf(buf, buflen, fmt,
                 ((aptr->body->type != TYPE_TEXT) || aptr->body->noconv) ? 'n' : 'c');
      }
      else if ((aptr->body->type != TYPE_TEXT) || aptr->body->noconv)
      {
        optional = false;
      }
      break;
    case 'd':
    {
      const char *const c_message_format = cs_subset_string(NeoMutt->sub, "message_format");
      if (!optional)
      {
        if (aptr->body->description)
        {
          mutt_format_s(buf, buflen, prec, aptr->body->description);
          break;
        }
        if (mutt_is_message_type(aptr->body->type, aptr->body->subtype) &&
            c_message_format && aptr->body->email)
        {
          char s[128] = { 0 };
          mutt_make_string(s, sizeof(s), cols, c_message_format, NULL, -1,
                           aptr->body->email,
                           MUTT_FORMAT_FORCESUBJ | MUTT_FORMAT_ARROWCURSOR, NULL);
          if (*s)
          {
            mutt_format_s(buf, buflen, prec, s);
            break;
          }
        }
        if (!aptr->body->d_filename && !aptr->body->filename)
        {
          mutt_format_s(buf, buflen, prec, "<no description>");
          break;
        }
      }
      else if (aptr->body->description ||
               (mutt_is_message_type(aptr->body->type, aptr->body->subtype) &&
                c_message_format && aptr->body->email))
      {
        break;
      }
    }
    /* fallthrough */
    case 'F':
      if (!optional)
      {
        if (aptr->body->d_filename)
        {
          mutt_format_s(buf, buflen, prec, aptr->body->d_filename);
          break;
        }
      }
      else if (!aptr->body->d_filename && !aptr->body->filename)
      {
        optional = false;
        break;
      }
    /* fallthrough */
    case 'f':
      if (!optional)
      {
        if (aptr->body->filename && (*aptr->body->filename == '/'))
        {
          struct Buffer *path = buf_pool_get();
 
          buf_strcpy(path, aptr->body->filename);
          buf_pretty_mailbox(path);
          mutt_format_s(buf, buflen, prec, buf_string(path));
          buf_pool_release(&path);
        }
        else
        {
          mutt_format_s(buf, buflen, prec, NONULL(aptr->body->filename));
        }
      }
      else if (!aptr->body->filename)
      {
        optional = false;
      }
      break;
    case 'D':
      if (!optional)
        snprintf(buf, buflen, "%c", aptr->body->deleted ? 'D' : ' ');
      else if (!aptr->body->deleted)
        optional = false;
      break;
    case 'e':
      if (!optional)
        mutt_format_s(buf, buflen, prec, ENCODING(aptr->body->encoding));
      break;
    case 'I':
      if (optional)
        break;
 
      const char dispchar[] = { 'I', 'A', 'F', '-' };
      char ch;
 
      if (aptr->body->disposition < sizeof(dispchar))
      {
        ch = dispchar[aptr->body->disposition];
      }
      else
      {
        mutt_debug(LL_DEBUG1, "ERROR: invalid content-disposition %d\n",
                   aptr->body->disposition);
        ch = '!';
      }
      snprintf(buf, buflen, "%c", ch);
      break;
    case 'm':
      if (!optional)
        mutt_format_s(buf, buflen, prec, TYPE(aptr->body));
      break;
    case 'M':
      if (!optional)
        mutt_format_s(buf, buflen, prec, aptr->body->subtype);
      else if (!aptr->body->subtype)
        optional = false;
      break;
    case 'n':
      if (optional)
        break;
 
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      snprintf(buf, buflen, fmt, aptr->num + 1);
      break;
    case 'Q':
      if (optional)
      {
        optional = aptr->body->attach_qualifies;
      }
      else
      {
        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
        mutt_format_s(buf, buflen, fmt, "Q");
      }
      break;
    case 's':
    {
      size_t l = 0;
      if (aptr->body->filename && (flags & MUTT_FORMAT_STAT_FILE))
      {
        l = mutt_file_get_size(aptr->body->filename);
      }
      else
      {
        l = aptr->body->length;
      }
 
      if (!optional)
      {
        char tmp[128] = { 0 };
        mutt_str_pretty_size(tmp, sizeof(tmp), l);
        mutt_format_s(buf, buflen, prec, tmp);
      }
      else if (l == 0)
      {
        optional = false;
      }
 
      break;
    }
    case 't':
      if (!optional)
        snprintf(buf, buflen, "%c", aptr->body->tagged ? '*' : ' ');
      else if (!aptr->body->tagged)
        optional = false;
      break;
    case 'T':
      if (!optional)
        mutt_format_s_tree(buf, buflen, prec, NONULL(aptr->tree));
      else if (!aptr->tree)
        optional = false;
      break;
    case 'u':
      if (!optional)
        snprintf(buf, buflen, "%c", aptr->body->unlink ? '-' : ' ');
      else if (!aptr->body->unlink)
        optional = false;
      break;
    case 'X':
      if (optional)
      {
        optional = ((aptr->body->attach_count + aptr->body->attach_qualifies) != 0);
      }
      else
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, aptr->body->attach_count + aptr->body->attach_qualifies);
      }
      break;
    default:
      *buf = '\0';
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, attach_format_str, data,
                        MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, attach_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

autocrypt_format_str()

static const char * autocrypt_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the Autocrypt account list - Implements format_t -.

Expando	Description
%a	Email address
%k	Gpg keyid
%n	Current entry number
%p	Prefer-encrypt flag
%s	Status flag (active/inactive)

Definition at line 123 of file dlg_autocrypt.c.

{
  struct AccountEntry *entry = (struct AccountEntry *) data;
  char tmp[128] = { 0 };
 
  switch (op)
  {
    case 'a':
      mutt_format_s(buf, buflen, prec, buf_string(entry->addr->mailbox));
      break;
    case 'k':
      mutt_format_s(buf, buflen, prec, entry->account->keyid);
      break;
    case 'n':
      snprintf(tmp, sizeof(tmp), "%%%sd", prec);
      snprintf(buf, buflen, tmp, entry->num);
      break;
    case 'p':
      if (entry->account->prefer_encrypt)
      {
        /* L10N: Autocrypt Account menu.
           flag that an account has prefer-encrypt set */
        mutt_format_s(buf, buflen, prec, _("prefer encrypt"));
      }
      else
      {
        /* L10N: Autocrypt Account menu.
           flag that an account has prefer-encrypt unset;
           thus encryption will need to be manually enabled.  */
        mutt_format_s(buf, buflen, prec, _("manual encrypt"));
      }
      break;
    case 's':
      if (entry->account->enabled)
      {
        /* L10N: Autocrypt Account menu.
           flag that an account is enabled/active */
        mutt_format_s(buf, buflen, prec, _("active"));
      }
      else
      {
        /* L10N: Autocrypt Account menu.
           flag that an account is disabled/inactive */
        mutt_format_s(buf, buflen, prec, _("inactive"));
      }
      break;
  }
 
  return (src);
}

Here is the call graph for this function:

Here is the caller graph for this function:

folder_format_str()

static const char * folder_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the folder browser - Implements format_t -.

Expando	Description
%a	Alert: 1 if user is notified of new mail
%C	Current file number
%d	Date/time folder was last modified
%D	Date/time folder was last modified using $date_format.
%F	File permissions
%f	Filename (with suffix /, @ or *)
%g	Group name (or numeric gid, if missing)
%i	Description of the folder
%l	Number of hard links
%m	Number of messages in the mailbox
%N	"N" if mailbox has new mail, " " (space) otherwise
%n	Number of unread messages in the mailbox
%p	Poll: 1 if Mailbox is checked for new mail
%s	Size in bytes
%t	* if the file is tagged, blank otherwise
%u	Owner name (or numeric uid, if missing)
%[fmt]	Date folder was last modified using strftime(3)

Definition at line 211 of file dlg_browser.c.

{
  char fn[128] = { 0 };
  char fmt[128] = { 0 };
  struct Folder *folder = (struct Folder *) data;
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'a':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->notify_user);
      }
      else
      {
        if (folder->ff->notify_user == 0)
          optional = false;
      }
      break;
 
    case 'C':
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      snprintf(buf, buflen, fmt, folder->num + 1);
      break;
 
    case 'd':
    case 'D':
      if (folder->ff->local)
      {
        bool use_c_locale = false;
 
        const char *t_fmt = NULL;
        if (op == 'D')
        {
          const char *const c_date_format = cs_subset_string(NeoMutt->sub, "date_format");
          t_fmt = NONULL(c_date_format);
          if (*t_fmt == '!')
          {
            t_fmt++;
            use_c_locale = true;
          }
        }
        else
        {
          static const time_t one_year = 31536000;
          t_fmt = ((mutt_date_now() - folder->ff->mtime) < one_year) ? "%b %d %H:%M" : "%b %d  %Y";
        }
 
        char date[128] = { 0 };
        if (use_c_locale)
        {
          mutt_date_localtime_format_locale(date, sizeof(date), t_fmt,
                                            folder->ff->mtime, NeoMutt->time_c_locale);
        }
        else
        {
          mutt_date_localtime_format(date, sizeof(date), t_fmt, folder->ff->mtime);
        }
 
        mutt_format_s(buf, buflen, prec, date);
      }
      else
      {
        mutt_format_s(buf, buflen, prec, "");
      }
      break;
 
    case '[':
      if (folder->ff->local)
      {
        char buf2[128] = { 0 };
        bool use_c_locale = false;
        struct tm tm = { 0 };
 
        char *p = buf;
 
        const char *cp = src;
        if (*cp == '!')
        {
          use_c_locale = true;
          cp++;
        }
 
        size_t len = buflen - 1;
        while ((len > 0) && (*cp != ']'))
        {
          if (*cp == '%')
          {
            cp++;
            if (len >= 2)
            {
              *p++ = '%';
              *p++ = *cp;
              len -= 2;
            }
            else
            {
              break; /* not enough space */
            }
            cp++;
          }
          else
          {
            *p++ = *cp++;
            len--;
          }
        }
        *p = '\0';
 
        tm = mutt_date_localtime(folder->ff->mtime);
 
        if (use_c_locale)
          strftime_l(buf2, sizeof(buf2), buf, &tm, NeoMutt->time_c_locale);
        else
          strftime(buf2, sizeof(buf2), buf, &tm);
 
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, buf2);
        if (len > 0)
          src = cp + 1;
      }
      else
      {
        mutt_format_s(buf, buflen, prec, "");
      }
      break;
 
    case 'f':
    {
      char *s = NULL;
 
      s = NONULL(folder->ff->name);
 
      snprintf(fn, sizeof(fn), "%s%s", s,
               folder->ff->local ?
                   (S_ISLNK(folder->ff->mode) ?
                        "@" :
                        (S_ISDIR(folder->ff->mode) ?
                             "/" :
                             (((folder->ff->mode & S_IXUSR) != 0) ? "*" : ""))) :
                   "");
 
      mutt_format_s(buf, buflen, prec, fn);
      break;
    }
    case 'F':
    {
      if (folder->ff->local)
      {
        char permission[11] = { 0 };
        snprintf(permission, sizeof(permission), "%c%c%c%c%c%c%c%c%c%c",
                 S_ISDIR(folder->ff->mode) ? 'd' : (S_ISLNK(folder->ff->mode) ? 'l' : '-'),
                 ((folder->ff->mode & S_IRUSR) != 0) ? 'r' : '-',
                 ((folder->ff->mode & S_IWUSR) != 0) ? 'w' : '-',
                 ((folder->ff->mode & S_ISUID) != 0) ? 's' :
                 ((folder->ff->mode & S_IXUSR) != 0) ? 'x' :
                                                       '-',
                 ((folder->ff->mode & S_IRGRP) != 0) ? 'r' : '-',
                 ((folder->ff->mode & S_IWGRP) != 0) ? 'w' : '-',
                 ((folder->ff->mode & S_ISGID) != 0) ? 's' :
                 ((folder->ff->mode & S_IXGRP) != 0) ? 'x' :
                                                       '-',
                 ((folder->ff->mode & S_IROTH) != 0) ? 'r' : '-',
                 ((folder->ff->mode & S_IWOTH) != 0) ? 'w' : '-',
                 ((folder->ff->mode & S_ISVTX) != 0) ? 't' :
                 ((folder->ff->mode & S_IXOTH) != 0) ? 'x' :
                                                       '-');
        mutt_format_s(buf, buflen, prec, permission);
      }
#ifdef USE_IMAP
      else if (folder->ff->imap)
      {
        char permission[11] = { 0 };
        /* mark folders with subfolders AND mail */
        snprintf(permission, sizeof(permission), "IMAP %c",
                 (folder->ff->inferiors && folder->ff->selectable) ? '+' : ' ');
        mutt_format_s(buf, buflen, prec, permission);
      }
#endif
      else
        mutt_format_s(buf, buflen, prec, "");
      break;
    }
 
    case 'g':
      if (folder->ff->local)
      {
        struct group *gr = getgrgid(folder->ff->gid);
        if (gr)
        {
          mutt_format_s(buf, buflen, prec, gr->gr_name);
        }
        else
        {
          snprintf(fmt, sizeof(fmt), "%%%sld", prec);
          snprintf(buf, buflen, fmt, folder->ff->gid);
        }
      }
      else
      {
        mutt_format_s(buf, buflen, prec, "");
      }
      break;
 
    case 'i':
    {
      char *s = NULL;
      if (folder->ff->desc)
        s = folder->ff->desc;
      else
        s = folder->ff->name;
 
      snprintf(fn, sizeof(fn), "%s%s", s,
               folder->ff->local ?
                   (S_ISLNK(folder->ff->mode) ?
                        "@" :
                        (S_ISDIR(folder->ff->mode) ?
                             "/" :
                             (((folder->ff->mode & S_IXUSR) != 0) ? "*" : ""))) :
                   "");
 
      mutt_format_s(buf, buflen, prec, fn);
      break;
    }
 
    case 'l':
      if (folder->ff->local)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->nlink);
      }
      else
      {
        mutt_format_s(buf, buflen, prec, "");
      }
      break;
 
    case 'm':
      if (!optional)
      {
        if (folder->ff->has_mailbox)
        {
          snprintf(fmt, sizeof(fmt), "%%%sd", prec);
          snprintf(buf, buflen, fmt, folder->ff->msg_count);
        }
        else
        {
          mutt_format_s(buf, buflen, prec, "");
        }
      }
      else if (folder->ff->msg_count == 0)
      {
        optional = false;
      }
      break;
 
    case 'N':
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      snprintf(buf, buflen, fmt, folder->ff->has_new_mail ? 'N' : ' ');
      break;
 
    case 'n':
      if (!optional)
      {
        if (folder->ff->has_mailbox)
        {
          snprintf(fmt, sizeof(fmt), "%%%sd", prec);
          snprintf(buf, buflen, fmt, folder->ff->msg_unread);
        }
        else
        {
          mutt_format_s(buf, buflen, prec, "");
        }
      }
      else if (folder->ff->msg_unread == 0)
      {
        optional = false;
      }
      break;
 
    case 'p':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->poll_new_mail);
      }
      else
      {
        if (folder->ff->poll_new_mail == 0)
          optional = false;
      }
      break;
 
    case 's':
      if (folder->ff->local)
      {
        mutt_str_pretty_size(fn, sizeof(fn), folder->ff->size);
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, fn);
      }
      else
      {
        mutt_format_s(buf, buflen, prec, "");
      }
      break;
 
    case 't':
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      snprintf(buf, buflen, fmt, folder->ff->tagged ? '*' : ' ');
      break;
 
    case 'u':
      if (folder->ff->local)
      {
        struct passwd *pw = getpwuid(folder->ff->uid);
        if (pw)
        {
          mutt_format_s(buf, buflen, prec, pw->pw_name);
        }
        else
        {
          snprintf(fmt, sizeof(fmt), "%%%sld", prec);
          snprintf(buf, buflen, fmt, folder->ff->uid);
        }
      }
      else
      {
        mutt_format_s(buf, buflen, prec, "");
      }
      break;
 
    default:
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      snprintf(buf, buflen, fmt, op);
      break;
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, folder_format_str, data,
                        MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, folder_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compress_format_str()

static const char * compress_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Expand the filenames in a command string - Implements format_t -.

Expando	Description
%f	Compressed file
%t	Plaintext, temporary file

Definition at line 255 of file compress.c.

{
  if (!buf || (data == 0))
    return src;
 
  struct Mailbox *m = (struct Mailbox *) data;
 
  /* NOTE the compressed file config vars expect %f and %t to be
   * surrounded by '' (unlike other NeoMutt config vars, which add the
   * outer quotes for the user).  This is why we use the
   * buf_quote_filename() form with add_outer of false. */
  struct Buffer *quoted = buf_pool_get();
  switch (op)
  {
    case 'f':
      /* Compressed file */
      buf_quote_filename(quoted, m->realpath, false);
      snprintf(buf, buflen, "%s", buf_string(quoted));
      break;
    case 't':
      /* Plaintext, temporary file */
      buf_quote_filename(quoted, mailbox_path(m), false);
      snprintf(buf, buflen, "%s", buf_string(quoted));
      break;
  }
 
  buf_pool_release(&quoted);
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compose_format_str()

static const char * compose_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Create the status bar string for compose mode - Implements format_t -.

Expando	Description
%a	Total number of attachments
%h	Local hostname
%l	Approximate size (in bytes) of the current message
%v	NeoMutt version string

Definition at line 104 of file cbar.c.

{
  char fmt[128], tmp[128];
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
  struct ComposeSharedData *shared = (struct ComposeSharedData *) data;
 
  *buf = '\0';
  switch (op)
  {
    case 'a': /* total number of attachments */
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      snprintf(buf, buflen, fmt, num_attachments(shared->adata));
      break;
 
    case 'h': /* hostname */
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, NONULL(ShortHostname));
      break;
 
    case 'l': /* approx length of current message in bytes */
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      mutt_str_pretty_size(tmp, sizeof(tmp),
                           cum_attachs_size(shared->sub, shared->adata));
      snprintf(buf, buflen, fmt, tmp);
      break;
 
    case 'v':
      snprintf(buf, buflen, "%s", mutt_make_version());
      break;
 
    case 0:
      *buf = '\0';
      return src;
 
    default:
      snprintf(buf, buflen, "%%%s%c", prec, op);
      break;
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, compose_format_str, data, flags);
  }
  // This format function doesn't have any optional expandos,
  // so there's no `else if (flags & MUTT_FORMAT_OPTIONAL)` clause
 
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

index_format_str()

static const char * index_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the index list - Implements format_t -.

Expando	Description
%a	Address of the author
%A	Reply-to address (if present; otherwise: address of author)
%b	Filename of the original message folder (think mailbox)
%B	The list to which the email was sent, or else the folder name (b)
%C	Current message number
%c	Number of characters (bytes) in the body of the message
%cr	Number of characters (bytes) in the message, including header
%D	Date and time of message using $date_format and local timezone
%d	Date and time of message using $date_format and sender's timezone
%e	Current message number in thread
%E	Number of messages in current thread
%Fp	Like F, but plain. No contextual formatting is applied to recipient name
%F	Author name, or recipient name if the message is from you
%f	Sender (address + real name), either From: or Return-Path:
%Gx	Individual message tag (e.g. notmuch tags/imap flags)
%g	Message tags (e.g. notmuch tags/imap flags)
%H	Spam attribute(s) of this message
%I	Initials of author
%i	Message-id of the current message
%J	Message tags (if present, tree unfolded, and != parent's tags)
%K	The list to which the email was sent (if any; otherwise: empty)
%L	Like F, except 'lists' are displayed first
%l	Number of lines in the message
%M	Number of hidden messages if the thread is collapsed
%m	Total number of message in the mailbox
%n	Author's real name (or address if missing)
%N	Message score
%O	Like L, except using address instead of name
%P	Progress indicator for the built-in pager (how much of the file has been displayed)
%q	Newsgroup name (if compiled with NNTP support)
%R	Comma separated list of Cc: recipients
%r	Comma separated list of To: recipients
%S	Single character status of the message (N/O/D/d/!/r/-)
%s	Subject of the message
%t	'To:' field (recipients)
%T	The appropriate character from the $to_chars string
%u	User (login) name of the author
%v	First name of the author, or the recipient if the message is from you
%W	Name of organization of author ('Organization:' field)
%x	'X-Comment-To:' field (if present and compiled with NNTP support)
%X	Number of MIME attachments
%y	'X-Label:' field (if present)
%Y	'X-Label:' field (if present, tree unfolded, and != parent's x-label)
%zc	Message crypto flags
%zs	Message status flags
%zt	Message tag flags
%Z	Combined message flags
%@name@	Insert and evaluate format-string from the matching "$index-format-hook" command
%(fmt)	Date/time when the message was received
%[fmt]	Message date/time converted to the local time zone
%{fmt}	Message date/time converted to sender's time zone

Definition at line 393 of file hdrline.c.

{
  struct HdrFormatInfo *hfi = (struct HdrFormatInfo *) data;
  char fmt[128], tmp[1024];
  char *p = NULL, *tags = NULL;
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
  const bool threads = mutt_using_threads();
  int is_index = (flags & MUTT_FORMAT_INDEX);
  size_t colorlen;
 
  struct Email *e = hfi->email;
  size_t msg_in_pager = hfi->msg_in_pager;
  struct Mailbox *m = hfi->mailbox;
 
  if (!e || !e->env)
    return src;
 
  const struct Address *reply_to = TAILQ_FIRST(&e->env->reply_to);
  const struct Address *from = TAILQ_FIRST(&e->env->from);
  const struct Address *to = TAILQ_FIRST(&e->env->to);
  const struct Address *cc = TAILQ_FIRST(&e->env->cc);
 
  const struct MbTable *c_crypt_chars = cs_subset_mbtable(NeoMutt->sub, "crypt_chars");
  const struct MbTable *c_flag_chars = cs_subset_mbtable(NeoMutt->sub, "flag_chars");
  const struct MbTable *c_to_chars = cs_subset_mbtable(NeoMutt->sub, "to_chars");
  const char *const c_date_format = cs_subset_string(NeoMutt->sub, "date_format");
 
  buf[0] = '\0';
  switch (op)
  {
    case 'A':
    case 'I':
      if (op == 'A')
      {
        if (reply_to && reply_to->mailbox)
        {
          colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
          mutt_format_s(buf + colorlen, buflen - colorlen, prec,
                        mutt_addr_for_display(reply_to));
          add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
          break;
        }
      }
      else
      {
        if (mutt_mb_get_initials(mutt_get_name(from), tmp, sizeof(tmp)))
        {
          colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
          mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
          add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
          break;
        }
      }
      /* fallthrough */
 
    case 'a':
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
      if (from && from->mailbox)
      {
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, mutt_addr_for_display(from));
      }
      else
      {
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
      }
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
 
    case 'B':
    case 'K':
      if (first_mailing_list(buf, buflen, &e->env->to) ||
          first_mailing_list(buf, buflen, &e->env->cc))
      {
        mutt_str_copy(tmp, buf, sizeof(tmp));
        mutt_format_s(buf, buflen, prec, tmp);
      }
      else if (optional)
      {
        optional = false;
      }
      break;
 
    case 'b':
      if (m)
      {
        p = strrchr(mailbox_path(m), '/');
#ifdef USE_NOTMUCH
        if (m->type == MUTT_NOTMUCH)
        {
          char *rel_path = nm_email_get_folder_rel_db(m, e);
          if (rel_path)
            p = rel_path;
        }
#endif
 
        if (p)
          mutt_str_copy(buf, p + 1, buflen);
        else
          mutt_str_copy(buf, mailbox_path(m), buflen);
      }
      else
      {
        mutt_str_copy(buf, "(null)", buflen);
      }
      mutt_str_copy(tmp, buf, sizeof(tmp));
      mutt_format_s(buf, buflen, prec, tmp);
      break;
 
    case 'c':
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
      if (src[0] == 'r')
      {
        mutt_str_pretty_size(tmp, sizeof(tmp), email_size(e));
        src++;
      }
      else
      {
        mutt_str_pretty_size(tmp, sizeof(tmp), e->body->length);
      }
      mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
 
    case 'C':
      colorlen = add_index_color(fmt, sizeof(fmt), flags, MT_COLOR_INDEX_NUMBER);
      snprintf(fmt + colorlen, sizeof(fmt) - colorlen, "%%%sd", prec);
      add_index_color(fmt + colorlen, sizeof(fmt) - colorlen, flags, MT_COLOR_INDEX);
      snprintf(buf, buflen, fmt, e->msgno + 1);
      break;
 
    case 'd':
    case 'D':
    case '{':
    case '[':
    case '(':
    case '<':
      /* preprocess $date_format to handle %Z */
      {
        const char *cp = NULL;
        time_t now;
        int j = 0;
 
        if (optional && ((op == '[') || (op == '(')))
        {
          now = mutt_date_now();
          struct tm tm = mutt_date_localtime(now);
          now -= (op == '(') ? e->received : e->date_sent;
 
          char *is = (char *) prec;
          bool invert = false;
          if (*is == '>')
          {
            invert = true;
            is++;
          }
 
          while (*is && (*is != '?'))
          {
            int t = strtol(is, &is, 10);
            /* semi-broken (assuming 30 days in all months) */
            switch (*(is++))
            {
              case 'y':
                if (t > 1)
                {
                  t--;
                  t *= (60 * 60 * 24 * 365);
                }
                t += ((tm.tm_mon * 60 * 60 * 24 * 30) + (tm.tm_mday * 60 * 60 * 24) +
                      (tm.tm_hour * 60 * 60) + (tm.tm_min * 60) + tm.tm_sec);
                break;
 
              case 'm':
                if (t > 1)
                {
                  t--;
                  t *= (60 * 60 * 24 * 30);
                }
                t += ((tm.tm_mday * 60 * 60 * 24) + (tm.tm_hour * 60 * 60) +
                      (tm.tm_min * 60) + tm.tm_sec);
                break;
 
              case 'w':
                if (t > 1)
                {
                  t--;
                  t *= (60 * 60 * 24 * 7);
                }
                t += ((tm.tm_wday * 60 * 60 * 24) + (tm.tm_hour * 60 * 60) +
                      (tm.tm_min * 60) + tm.tm_sec);
                break;
 
              case 'd':
                if (t > 1)
                {
                  t--;
                  t *= (60 * 60 * 24);
                }
                t += ((tm.tm_hour * 60 * 60) + (tm.tm_min * 60) + tm.tm_sec);
                break;
 
              case 'H':
                if (t > 1)
                {
                  t--;
                  t *= (60 * 60);
                }
                t += ((tm.tm_min * 60) + tm.tm_sec);
                break;
 
              case 'M':
                if (t > 1)
                {
                  t--;
                  t *= (60);
                }
                t += (tm.tm_sec);
                break;
 
              default:
                break;
            }
            j += t;
          }
 
          if (j < 0)
            j *= -1;
 
          if (((now > j) || (now < (-1 * j))) ^ invert)
            optional = false;
          break;
        }
 
        p = buf;
 
        cp = ((op == 'd') || (op == 'D')) ? (NONULL(c_date_format)) : src;
        bool use_c_locale = false;
        if (*cp == '!')
        {
          use_c_locale = true;
          cp++;
        }
 
        size_t len = buflen - 1;
        while ((len > 0) &&
               ((((op == 'd') || (op == 'D')) && *cp) ||
                ((op == '{') && (*cp != '}')) || ((op == '[') && (*cp != ']')) ||
                ((op == '(') && (*cp != ')')) || ((op == '<') && (*cp != '>'))))
        {
          if (*cp == '%')
          {
            cp++;
            if (((*cp == 'Z') || (*cp == 'z')) && ((op == 'd') || (op == '{')))
            {
              if (len >= 5)
              {
                sprintf(p, "%c%02u%02u", e->zoccident ? '-' : '+', e->zhours, e->zminutes);
                p += 5;
                len -= 5;
              }
              else
              {
                break; /* not enough space left */
              }
            }
            else
            {
              if (len >= 2)
              {
                *p++ = '%';
                *p++ = *cp;
                len -= 2;
              }
              else
              {
                break; /* not enough space */
              }
            }
            cp++;
          }
          else
          {
            *p++ = *cp++;
            len--;
          }
        }
        *p = '\0';
 
        struct tm tm = { 0 };
        if ((op == '[') || (op == 'D'))
        {
          tm = mutt_date_localtime(e->date_sent);
        }
        else if (op == '(')
        {
          tm = mutt_date_localtime(e->received);
        }
        else if (op == '<')
        {
          tm = mutt_date_localtime(mutt_date_now());
        }
        else
        {
          /* restore sender's time zone */
          now = e->date_sent;
          if (e->zoccident)
            now -= (e->zhours * 3600 + e->zminutes * 60);
          else
            now += (e->zhours * 3600 + e->zminutes * 60);
          tm = mutt_date_gmtime(now);
        }
 
        if (use_c_locale)
          strftime_l(tmp, sizeof(tmp), buf, &tm, NeoMutt->time_c_locale);
        else
          strftime(tmp, sizeof(tmp), buf, &tm);
 
        colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_DATE);
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
        add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
 
        if ((len > 0) && (op != 'd') && (op != 'D')) /* Skip ending op */
          src = cp + 1;
        break;
      }
 
    case 'e':
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      snprintf(buf, buflen, fmt, mutt_messages_in_thread(m, e, MIT_POSITION));
      break;
 
    case 'E':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, mutt_messages_in_thread(m, e, MIT_NUM_MESSAGES));
      }
      else if (mutt_messages_in_thread(m, e, MIT_NUM_MESSAGES) <= 1)
      {
        optional = false;
      }
      break;
 
    case 'f':
    {
      struct Buffer *tmpbuf = buf_pool_get();
      mutt_addrlist_write(&e->env->from, tmpbuf, true);
      mutt_str_copy(tmp, buf_string(tmpbuf), sizeof(tmp));
      buf_pool_release(&tmpbuf);
      mutt_format_s(buf, buflen, prec, tmp);
      break;
    }
 
    case 'F':
      if (!optional)
      {
        const bool is_plain = (src[0] == 'p');
        colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
        make_from(e->env, tmp, sizeof(tmp), false,
                  (is_plain ? MUTT_FORMAT_PLAIN : MUTT_FORMAT_NO_FLAGS));
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
        add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
 
        if (is_plain)
          src++;
      }
      else if (mutt_addr_is_user(from))
      {
        optional = false;
      }
      break;
 
    case 'g':
      tags = driver_tags_get_transformed(&e->tags);
      if (!optional)
      {
        colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
        add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      }
      else if (!tags)
      {
        optional = false;
      }
      FREE(&tags);
      break;
 
    case 'G':
    {
      char format[3] = { 0 };
      char *tag = NULL;
 
      if (!optional)
      {
        format[0] = op;
        format[1] = *src;
        format[2] = '\0';
 
        tag = mutt_hash_find(TagFormats, format);
        if (tag)
        {
          tags = driver_tags_get_transformed_for(&e->tags, tag);
          colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAG);
          mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
          add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
          FREE(&tags);
        }
        src++;
      }
      else
      {
        format[0] = op;
        format[1] = *prec;
        format[2] = '\0';
 
        tag = mutt_hash_find(TagFormats, format);
        if (tag)
        {
          tags = driver_tags_get_transformed_for(&e->tags, tag);
          if (!tags)
            optional = false;
          FREE(&tags);
        }
      }
      break;
    }
 
    case 'H':
      /* (Hormel) spam score */
      if (optional)
        optional = !buf_is_empty(&e->env->spam);
 
      mutt_format_s(buf, buflen, prec, buf_string(&e->env->spam));
      break;
 
    case 'i':
      mutt_format_s(buf, buflen, prec, e->env->message_id ? e->env->message_id : "<no.id>");
      break;
 
    case 'J':
    {
      bool have_tags = true;
      tags = driver_tags_get_transformed(&e->tags);
      if (tags)
      {
        if (flags & MUTT_FORMAT_TREE)
        {
          char *parent_tags = NULL;
          if (e->thread->prev && e->thread->prev->message)
          {
            parent_tags = driver_tags_get_transformed(&e->thread->prev->message->tags);
          }
          if (!parent_tags && e->thread->parent && e->thread->parent->message)
          {
            parent_tags = driver_tags_get_transformed(
                &e->thread->parent->message->tags);
          }
          if (parent_tags && mutt_istr_equal(tags, parent_tags))
            have_tags = false;
          FREE(&parent_tags);
        }
      }
      else
      {
        have_tags = false;
      }
 
      if (optional)
        optional = have_tags;
 
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
      if (have_tags)
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, tags);
      else
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      FREE(&tags);
      break;
    }
 
    case 'l':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
        snprintf(buf + colorlen, buflen - colorlen, fmt, e->lines);
        add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      }
      else if (e->lines <= 0)
      {
        optional = false;
      }
      break;
 
    case 'L':
      if (!optional)
      {
        colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
        make_from(e->env, tmp, sizeof(tmp), true, flags);
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
        add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      }
      else if (!check_for_mailing_list(&e->env->to, NULL, NULL, 0) &&
               !check_for_mailing_list(&e->env->cc, NULL, NULL, 0))
      {
        optional = false;
      }
      break;
 
    case 'm':
      if (m)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_count);
      }
      else
      {
        mutt_str_copy(buf, "(null)", buflen);
      }
      break;
 
    case 'n':
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
      mutt_format_s(buf + colorlen, buflen - colorlen, prec, mutt_get_name(from));
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
 
    case 'M':
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      if (!optional)
      {
        colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_COLLAPSED);
        if (threads && is_index && e->collapsed && (e->num_hidden > 1))
        {
          snprintf(buf + colorlen, buflen - colorlen, fmt, e->num_hidden);
          add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
        }
        else if (is_index && threads)
        {
          mutt_format_s(buf + colorlen, buflen - colorlen, prec, " ");
          add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
        }
        else
        {
          *buf = '\0';
        }
      }
      else
      {
        if (!(threads && is_index && e->collapsed && (e->num_hidden > 1)))
          optional = false;
      }
      break;
 
    case 'N':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, e->score);
      }
      else
      {
        if (e->score == 0)
          optional = false;
      }
      break;
 
    case 'O':
      if (!optional)
      {
        make_from_addr(e->env, tmp, sizeof(tmp), true);
        const bool c_save_address = cs_subset_bool(NeoMutt->sub, "save_address");
        if (!c_save_address && (p = strpbrk(tmp, "%@")))
          *p = '\0';
        mutt_format_s(buf, buflen, prec, tmp);
      }
      else if (!check_for_mailing_list_addr(&e->env->to, NULL, 0) &&
               !check_for_mailing_list_addr(&e->env->cc, NULL, 0))
      {
        optional = false;
      }
      break;
 
    case 'P':
      mutt_str_copy(buf, hfi->pager_progress, buflen);
      break;
 
#ifdef USE_NNTP
    case 'q':
      mutt_format_s(buf, buflen, prec, e->env->newsgroups ? e->env->newsgroups : "");
      break;
#endif
 
    case 'r':
    {
      struct Buffer *tmpbuf = buf_pool_get();
      mutt_addrlist_write(&e->env->to, tmpbuf, true);
      mutt_str_copy(tmp, buf_string(tmpbuf), sizeof(tmp));
      buf_pool_release(&tmpbuf);
      if (optional && (tmp[0] == '\0'))
        optional = false;
      mutt_format_s(buf, buflen, prec, tmp);
      break;
    }
 
    case 'R':
    {
      struct Buffer *tmpbuf = buf_pool_get();
      mutt_addrlist_write(&e->env->cc, tmpbuf, true);
      mutt_str_copy(tmp, buf_string(tmpbuf), sizeof(tmp));
      buf_pool_release(&tmpbuf);
      if (optional && (tmp[0] == '\0'))
        optional = false;
      mutt_format_s(buf, buflen, prec, tmp);
      break;
    }
 
    case 's':
    {
      subjrx_apply_mods(e->env);
      char *subj = NULL;
      if (e->env->disp_subj)
        subj = e->env->disp_subj;
      else
        subj = e->env->subject;
      if (flags & MUTT_FORMAT_TREE && !e->collapsed)
      {
        if (flags & MUTT_FORMAT_FORCESUBJ)
        {
          colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
          mutt_format_s(buf + colorlen, buflen - colorlen, "", NONULL(subj));
          add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
          snprintf(tmp, sizeof(tmp), "%s%s", e->tree, buf);
          mutt_format_s_tree(buf, buflen, prec, tmp);
        }
        else
        {
          mutt_format_s_tree(buf, buflen, prec, e->tree);
        }
      }
      else
      {
        colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(subj));
        add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      }
      break;
    }
 
    case 'S':
    {
      const char *wch = NULL;
      if (e->deleted)
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_DELETED);
      else if (e->attach_del)
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_DELETED_ATTACH);
      else if (e->tagged)
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_TAGGED);
      else if (e->flagged)
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_IMPORTANT);
      else if (e->replied)
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_REPLIED);
      else if (e->read && (msg_in_pager != e->msgno))
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_SEMPTY);
      else if (e->old)
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_OLD);
      else
        wch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_NEW);
 
      snprintf(tmp, sizeof(tmp), "%s", wch);
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
      mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
    }
 
    case 't':
      tmp[0] = '\0';
      if (!check_for_mailing_list(&e->env->to, "To ", tmp, sizeof(tmp)) &&
          !check_for_mailing_list(&e->env->cc, "Cc ", tmp, sizeof(tmp)))
      {
        if (to)
          snprintf(tmp, sizeof(tmp), "To %s", mutt_get_name(to));
        else if (cc)
          snprintf(tmp, sizeof(tmp), "Cc %s", mutt_get_name(cc));
      }
      mutt_format_s(buf, buflen, prec, tmp);
      break;
 
    case 'T':
    {
      int i;
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt,
               (c_to_chars && ((i = user_is_recipient(e))) < c_to_chars->len) ?
                   c_to_chars->chars[i] :
                   " ");
      break;
    }
 
    case 'u':
      if (from && from->mailbox)
      {
        mutt_str_copy(tmp, mutt_addr_for_display(from), sizeof(tmp));
        p = strpbrk(tmp, "%@");
        if (p)
          *p = '\0';
      }
      else
      {
        tmp[0] = '\0';
      }
      mutt_format_s(buf, buflen, prec, tmp);
      break;
 
    case 'v':
      if (mutt_addr_is_user(from))
      {
        if (to)
          mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(to));
        else if (cc)
          mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(cc));
        else
          *tmp = '\0';
      }
      else
      {
        mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(from));
      }
      p = strpbrk(tmp, " %@");
      if (p)
        *p = '\0';
      mutt_format_s(buf, buflen, prec, tmp);
      break;
 
    case 'W':
      if (!optional)
      {
        mutt_format_s(buf, buflen, prec, e->env->organization ? e->env->organization : "");
      }
      else if (!e->env->organization)
      {
        optional = false;
      }
      break;
 
#ifdef USE_NNTP
    case 'x':
      if (!optional)
      {
        mutt_format_s(buf, buflen, prec, e->env->x_comment_to ? e->env->x_comment_to : "");
      }
      else if (!e->env->x_comment_to)
      {
        optional = false;
      }
      break;
#endif
 
    case 'X':
    {
      struct Message *msg = mx_msg_open(m, e);
      if (msg)
      {
        int count = mutt_count_body_parts(m, e, msg->fp);
        mx_msg_close(m, &msg);
 
        /* The recursion allows messages without depth to return 0. */
        if (optional)
          optional = (count != 0);
 
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, count);
      }
      break;
    }
 
    case 'y':
      if (optional)
        optional = (e->env->x_label != NULL);
 
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
      mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(e->env->x_label));
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
 
    case 'Y':
    {
      bool label = true;
      if (e->env->x_label)
      {
        struct Email *e_tmp = NULL;
        if (flags & MUTT_FORMAT_TREE && (e->thread->prev && e->thread->prev->message &&
                                         e->thread->prev->message->env->x_label))
        {
          e_tmp = e->thread->prev->message;
        }
        else if (flags & MUTT_FORMAT_TREE &&
                 (e->thread->parent && e->thread->parent->message &&
                  e->thread->parent->message->env->x_label))
        {
          e_tmp = e->thread->parent->message;
        }
        if (e_tmp && mutt_istr_equal(e->env->x_label, e_tmp->env->x_label))
          label = false;
      }
      else
      {
        label = false;
      }
 
      if (optional)
        optional = label;
 
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
      if (label)
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(e->env->x_label));
      else
        mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
    }
 
    case 'z':
      if (src[0] == 's') /* status: deleted/new/old/replied */
      {
        const char *ch = NULL;
        if (e->deleted)
        {
          ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_DELETED);
        }
        else if (e->attach_del)
        {
          ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_DELETED_ATTACH);
        }
        else if (threads && thread_is_new(e))
        {
          ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_NEW_THREAD);
        }
        else if (threads && thread_is_old(e))
        {
          ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_OLD_THREAD);
        }
        else if (e->read && (msg_in_pager != e->msgno))
        {
          if (e->replied)
            ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_REPLIED);
          else
            ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_ZEMPTY);
        }
        else
        {
          if (e->old)
            ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_OLD);
          else
            ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_NEW);
        }
 
        snprintf(tmp, sizeof(tmp), "%s", ch);
        src++;
      }
      else if (src[0] == 'c') /* crypto */
      {
        const char *ch = NULL;
        if ((WithCrypto != 0) && (e->security & SEC_GOODSIGN))
        {
          ch = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_GOOD_SIGN);
        }
        else if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
        {
          ch = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_ENCRYPTED);
        }
        else if ((WithCrypto != 0) && (e->security & SEC_SIGN))
        {
          ch = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_SIGNED);
        }
        else if (((WithCrypto & APPLICATION_PGP) != 0) && ((e->security & PGP_KEY) == PGP_KEY))
        {
          ch = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_CONTAINS_KEY);
        }
        else
        {
          ch = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_NO_CRYPTO);
        }
 
        snprintf(tmp, sizeof(tmp), "%s", ch);
        src++;
      }
      else if (src[0] == 't') /* tagged, flagged, recipient */
      {
        const char *ch = NULL;
        if (e->tagged)
          ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_TAGGED);
        else if (e->flagged)
          ch = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_IMPORTANT);
        else
          ch = mbtable_get_nth_wchar(c_to_chars, user_is_recipient(e));
 
        snprintf(tmp, sizeof(tmp), "%s", ch);
        src++;
      }
      else /* fallthrough */
      {
        break;
      }
 
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
      mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
 
    case 'Z':
    {
      /* New/Old for threads; replied; New/Old for messages */
      const char *first = NULL;
      if (threads && thread_is_new(e))
      {
        first = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_NEW_THREAD);
      }
      else if (threads && thread_is_old(e))
      {
        first = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_OLD_THREAD);
      }
      else if (e->read && (msg_in_pager != e->msgno))
      {
        if (e->replied)
          first = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_REPLIED);
        else
          first = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_ZEMPTY);
      }
      else
      {
        if (e->old)
          first = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_OLD);
        else
          first = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_NEW);
      }
 
      /* Marked for deletion; deleted attachments; crypto */
      const char *second = NULL;
      if (e->deleted)
        second = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_DELETED);
      else if (e->attach_del)
        second = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_DELETED_ATTACH);
      else if ((WithCrypto != 0) && (e->security & SEC_GOODSIGN))
        second = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_GOOD_SIGN);
      else if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
        second = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_ENCRYPTED);
      else if ((WithCrypto != 0) && (e->security & SEC_SIGN))
        second = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_SIGNED);
      else if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & PGP_KEY))
        second = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_CONTAINS_KEY);
      else
        second = mbtable_get_nth_wchar(c_crypt_chars, FLAG_CHAR_CRYPT_NO_CRYPTO);
 
      /* Tagged, flagged and recipient flag */
      const char *third = NULL;
      if (e->tagged)
        third = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_TAGGED);
      else if (e->flagged)
        third = mbtable_get_nth_wchar(c_flag_chars, FLAG_CHAR_IMPORTANT);
      else
        third = mbtable_get_nth_wchar(c_to_chars, user_is_recipient(e));
 
      snprintf(tmp, sizeof(tmp), "%s%s%s", first, second, third);
    }
 
      colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
      mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
      add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
      break;
 
    case '@':
    {
      if (!m)
        break;
 
      const char *end = src;
      static unsigned char recurse = 0;
 
      while ((*end != '\0') && (*end != '@'))
        end++;
      if ((*end == '@') && (recurse < 20))
      {
        recurse++;
        mutt_strn_copy(tmp, src, end - src, sizeof(tmp));
        mutt_expando_format(tmp, sizeof(tmp), col, cols,
                            NONULL(mutt_idxfmt_hook(tmp, m, e)),
                            index_format_str, data, flags);
        mutt_format_s_x(buf, buflen, prec, tmp, true);
        recurse--;
 
        src = end + 1;
        break;
      }
    }
      /* fallthrough */
 
    default:
      snprintf(buf, buflen, "%%%s%c", prec, op);
      break;
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, index_format_str, data, flags);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, index_format_str, data, flags);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

history_format_str()

static const char * history_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the history list - Implements format_t -.

Expando	Description
%s	History match

Definition at line 91 of file dlg_history.c.

{
  char *match = (char *) data;
 
  if (op == 's')
  {
    mutt_format_s(buf, buflen, prec, match);
  }
 
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mix_format_str()

static const char * mix_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the remailer menu - Implements format_t -.

Expando	Description
%a	The remailer's e-mail address
%c	Remailer capabilities
%n	The running number on the menu
%s	The remailer's short name

Definition at line 119 of file win_hosts.c.

{
  char fmt[128] = { 0 };
  struct Remailer *remailer = (struct Remailer *) data;
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'a':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(remailer->addr));
      }
      else if (!remailer->addr)
      {
        optional = false;
      }
      break;
 
    case 'c':
      if (optional)
        break;
 
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, mix_format_caps(remailer));
      break;
 
    case 'n':
      if (optional)
        break;
 
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      snprintf(buf, buflen, fmt, remailer->num);
      break;
 
    case 's':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(remailer->shortname));
      }
      else if (!remailer->shortname)
      {
        optional = false;
      }
      break;
 
    default:
      *buf = '\0';
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, mix_format_str, data,
                        MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, mix_format_str, data,
                        MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_expando_format()

void mutt_expando_format	(	char *	buf,
		size_t	buflen,
		size_t	col,
		int	cols,
		const char *	src,
		format_t	callback,
		intptr_t	data,
		MuttFormatFlags	flags
	)

Expand expandos (x) in a string -.

Parameters

[out]	buf	Buffer in which to save string
[in]	buflen	Buffer length
[in]	col	Starting column
[in]	cols	Number of screen columns
[in]	src	Printf-like format string
[in]	callback	Callback - Implements format_t
[in]	data	Callback data
[in]	flags	Callback flags

Definition at line 745 of file muttlib.c.

{
  char prefix[128], tmp[1024];
  char *cp = NULL, *wptr = buf;
  char ch;
  char if_str[128], else_str[128];
  size_t wlen, count, len, wid;
  FILE *fp_filter = NULL;
  char *recycler = NULL;
 
  char src2[1024];
  mutt_str_copy(src2, src, mutt_str_len(src) + 1);
  src = src2;
 
  const bool c_arrow_cursor = cs_subset_bool(NeoMutt->sub, "arrow_cursor");
  const char *const c_arrow_string = cs_subset_string(NeoMutt->sub, "arrow_string");
  const int arrow_width = mutt_strwidth(c_arrow_string);
 
  prefix[0] = '\0';
  buflen--; /* save room for the terminal \0 */
  wlen = ((flags & MUTT_FORMAT_ARROWCURSOR) && c_arrow_cursor) ? arrow_width + 1 : 0;
  col += wlen;
 
  if ((flags & MUTT_FORMAT_NOFILTER) == 0)
  {
    int off = -1;
 
    /* Do not consider filters if no pipe at end */
    int n = mutt_str_len(src);
    if ((n > 1) && (src[n - 1] == '|'))
    {
      /* Scan backwards for backslashes */
      off = n;
      while ((off > 0) && (src[off - 2] == '\\'))
        off--;
    }
 
    /* If number of backslashes is even, the pipe is real. */
    /* n-off is the number of backslashes. */
    if ((off > 0) && (((n - off) % 2) == 0))
    {
      char srccopy[1024] = { 0 };
      int i = 0;
 
      mutt_debug(LL_DEBUG3, "fmtpipe = %s\n", src);
 
      strncpy(srccopy, src, n);
      srccopy[n - 1] = '\0';
 
      /* prepare Buffers */
      struct Buffer srcbuf = buf_make(0);
      buf_addstr(&srcbuf, srccopy);
      /* note: we are resetting dptr and *reading* from the buffer, so we don't
       * want to use buf_reset(). */
      buf_seek(&srcbuf, 0);
      struct Buffer word = buf_make(0);
      struct Buffer cmd = buf_make(0);
 
      /* Iterate expansions across successive arguments */
      do
      {
        /* Extract the command name and copy to command line */
        mutt_debug(LL_DEBUG3, "fmtpipe +++: %s\n", srcbuf.dptr);
        if (word.data)
          *word.data = '\0';
        parse_extract_token(&word, &srcbuf, TOKEN_NO_FLAGS);
        mutt_debug(LL_DEBUG3, "fmtpipe %2d: %s\n", i++, word.data);
        buf_addch(&cmd, '\'');
        mutt_expando_format(tmp, sizeof(tmp), 0, cols, word.data, callback,
                            data, flags | MUTT_FORMAT_NOFILTER);
        for (char *p = tmp; p && (*p != '\0'); p++)
        {
          if (*p == '\'')
          {
            /* shell quoting doesn't permit escaping a single quote within
             * single-quoted material.  double-quoting instead will lead
             * shell variable expansions, so break out of the single-quoted
             * span, insert a double-quoted single quote, and resume. */
            buf_addstr(&cmd, "'\"'\"'");
          }
          else
          {
            buf_addch(&cmd, *p);
          }
        }
        buf_addch(&cmd, '\'');
        buf_addch(&cmd, ' ');
      } while (MoreArgs(&srcbuf));
 
      mutt_debug(LL_DEBUG3, "fmtpipe > %s\n", cmd.data);
 
      col -= wlen; /* reset to passed in value */
      wptr = buf;  /* reset write ptr */
      pid_t pid = filter_create(cmd.data, NULL, &fp_filter, NULL, EnvList);
      if (pid != -1)
      {
        int rc;
 
        n = fread(buf, 1, buflen /* already decremented */, fp_filter);
        mutt_file_fclose(&fp_filter);
        rc = filter_wait(pid);
        if (rc != 0)
          mutt_debug(LL_DEBUG1, "format pipe cmd exited code %d\n", rc);
        if (n > 0)
        {
          buf[n] = '\0';
          while ((n > 0) && ((buf[n - 1] == '\n') || (buf[n - 1] == '\r')))
            buf[--n] = '\0';
          mutt_debug(LL_DEBUG5, "fmtpipe < %s\n", buf);
 
          /* If the result ends with '%', this indicates that the filter
           * generated %-tokens that neomutt can expand.  Eliminate the '%'
           * marker and recycle the string through mutt_expando_format().
           * To literally end with "%", use "%%". */
          if ((n > 0) && (buf[n - 1] == '%'))
          {
            n--;
            buf[n] = '\0'; /* remove '%' */
            if ((n > 0) && (buf[n - 1] != '%'))
            {
              recycler = mutt_str_dup(buf);
              if (recycler)
              {
                /* buflen is decremented at the start of this function
                 * to save space for the terminal nul char.  We can add
                 * it back for the recursive call since the expansion of
                 * format pipes does not try to append a nul itself.  */
                mutt_expando_format(buf, buflen + 1, col, cols, recycler,
                                    callback, data, flags);
                FREE(&recycler);
              }
            }
          }
        }
        else
        {
          /* read error */
          mutt_debug(LL_DEBUG1, "error reading from fmtpipe: %s (errno=%d)\n",
                     strerror(errno), errno);
          *wptr = '\0';
        }
      }
      else
      {
        /* Filter failed; erase write buffer */
        *wptr = '\0';
      }
 
      buf_dealloc(&cmd);
      buf_dealloc(&srcbuf);
      buf_dealloc(&word);
      return;
    }
  }
 
  while (*src && (wlen < buflen))
  {
    if (*src == '%')
    {
      if (*++src == '%')
      {
        *wptr++ = '%';
        wlen++;
        col++;
        src++;
        continue;
      }
 
      if (*src == '?')
      {
        /* change original %? to new %< notation */
        /* %?x?y&z? to %<x?y&z> where y and z are nestable */
        char *p = (char *) src;
        *p = '<';
        /* skip over "x" */
        for (; *p && (*p != '?'); p++)
          ; // do nothing
 
        /* nothing */
        if (*p == '?')
          p++;
        /* fix up the "y&z" section */
        for (; *p && (*p != '?'); p++)
        {
          /* escape '<' and '>' to work inside nested-if */
          if ((*p == '<') || (*p == '>'))
          {
            memmove(p + 2, p, mutt_str_len(p) + 1);
            *p++ = '\\';
            *p++ = '\\';
          }
        }
        if (*p == '?')
          *p = '>';
      }
 
      if (*src == '<')
      {
        flags |= MUTT_FORMAT_OPTIONAL;
        ch = *(++src); /* save the character to switch on */
        src++;
        cp = prefix;
        count = 0;
        while ((count < (sizeof(prefix) - 1)) && (*src != '\0') && (*src != '?'))
        {
          *cp++ = *src++;
          count++;
        }
        *cp = '\0';
      }
      else
      {
        flags &= ~MUTT_FORMAT_OPTIONAL;
 
        /* eat the format string */
        cp = prefix;
        count = 0;
        while ((count < (sizeof(prefix) - 1)) && strchr("0123456789.-=", *src))
        {
          *cp++ = *src++;
          count++;
        }
        *cp = '\0';
 
        if (*src == '\0')
          break; /* bad format */
 
        ch = *src++; /* save the character to switch on */
      }
 
      if (flags & MUTT_FORMAT_OPTIONAL)
      {
        int lrbalance;
 
        if (*src != '?')
          break; /* bad format */
        src++;
 
        /* eat the 'if' part of the string */
        cp = if_str;
        count = 0;
        lrbalance = 1;
        while ((lrbalance > 0) && (count < sizeof(if_str)) && *src)
        {
          if ((src[0] == '%') && (src[1] == '>'))
          {
            /* This is a padding expando; copy two chars and carry on */
            *cp++ = *src++;
            *cp++ = *src++;
            count += 2;
            continue;
          }
 
          if (*src == '\\')
          {
            src++;
            *cp++ = *src++;
          }
          else if ((src[0] == '%') && (src[1] == '<'))
          {
            lrbalance++;
          }
          else if (src[0] == '>')
          {
            lrbalance--;
          }
          if (lrbalance == 0)
            break;
          if ((lrbalance == 1) && (src[0] == '&'))
            break;
          *cp++ = *src++;
          count++;
        }
        *cp = '\0';
 
        /* eat the 'else' part of the string (optional) */
        if (*src == '&')
          src++; /* skip the & */
        cp = else_str;
        count = 0;
        while ((lrbalance > 0) && (count < sizeof(else_str)) && (*src != '\0'))
        {
          if ((src[0] == '%') && (src[1] == '>'))
          {
            /* This is a padding expando; copy two chars and carry on */
            *cp++ = *src++;
            *cp++ = *src++;
            count += 2;
            continue;
          }
 
          if (*src == '\\')
          {
            src++;
            *cp++ = *src++;
          }
          else if ((src[0] == '%') && (src[1] == '<'))
          {
            lrbalance++;
          }
          else if (src[0] == '>')
          {
            lrbalance--;
          }
          if (lrbalance == 0)
            break;
          if ((lrbalance == 1) && (src[0] == '&'))
            break;
          *cp++ = *src++;
          count++;
        }
        *cp = '\0';
 
        if ((*src == '\0'))
          break; /* bad format */
 
        src++; /* move past the trailing '>' (formerly '?') */
      }
 
      /* handle generic cases first */
      if ((ch == '>') || (ch == '*'))
      {
        /* %>X: right justify to EOL, left takes precedence
         * %*X: right justify to EOL, right takes precedence */
        int soft = ch == '*';
        int pl, pw;
        pl = mutt_mb_charlen(src, &pw);
        if (pl <= 0)
        {
          pl = 1;
          pw = 1;
        }
 
        /* see if there's room to add content, else ignore */
        if (((col < cols) && (wlen < buflen)) || soft)
        {
          int pad;
 
          /* get contents after padding */
          mutt_expando_format(tmp, sizeof(tmp), 0, cols, src + pl, callback, data, flags);
          len = mutt_str_len(tmp);
          wid = mutt_strwidth(tmp);
 
          pad = (cols - col - wid) / pw;
          if (pad >= 0)
          {
            /* try to consume as many columns as we can, if we don't have
             * memory for that, use as much memory as possible */
            if (wlen + (pad * pl) + len > buflen)
            {
              pad = (buflen > (wlen + len)) ? ((buflen - wlen - len) / pl) : 0;
            }
            else
            {
              /* Add pre-spacing to make multi-column pad characters and
               * the contents after padding line up */
              while (((col + (pad * pw) + wid) < cols) && ((wlen + (pad * pl) + len) < buflen))
              {
                *wptr++ = ' ';
                wlen++;
                col++;
              }
            }
            while (pad-- > 0)
            {
              memcpy(wptr, src, pl);
              wptr += pl;
              wlen += pl;
              col += pw;
            }
          }
          else if (soft)
          {
            int offset = ((flags & MUTT_FORMAT_ARROWCURSOR) && c_arrow_cursor) ?
                             arrow_width + 1 :
                             0;
            int avail_cols = (cols > offset) ? (cols - offset) : 0;
            /* \0-terminate buf for length computation in mutt_wstr_trunc() */
            *wptr = '\0';
            /* make sure right part is at most as wide as display */
            len = mutt_wstr_trunc(tmp, buflen, avail_cols, &wid);
            /* truncate left so that right part fits completely in */
            wlen = mutt_wstr_trunc(buf, buflen - len, avail_cols - wid, &col);
            wptr = buf + wlen;
            /* Multi-column characters may be truncated in the middle.
             * Add spacing so the right hand side lines up. */
            while (((col + wid) < avail_cols) && ((wlen + len) < buflen))
            {
              *wptr++ = ' ';
              wlen++;
              col++;
            }
          }
          if ((len + wlen) > buflen)
            len = mutt_wstr_trunc(tmp, buflen - wlen, cols - col, NULL);
          memcpy(wptr, tmp, len);
          wptr += len;
        }
        break; /* skip rest of input */
      }
      else if (ch == '|')
      {
        /* pad to EOL */
        int pl, pw;
        pl = mutt_mb_charlen(src, &pw);
        if (pl <= 0)
        {
          pl = 1;
          pw = 1;
        }
 
        /* see if there's room to add content, else ignore */
        if ((col < cols) && (wlen < buflen))
        {
          int c = (cols - col) / pw;
          if ((c > 0) && ((wlen + (c * pl)) > buflen))
            c = ((signed) (buflen - wlen)) / pl;
          while (c > 0)
          {
            memcpy(wptr, src, pl);
            wptr += pl;
            wlen += pl;
            col += pw;
            c--;
          }
        }
        break; /* skip rest of input */
      }
      else
      {
        bool to_lower = false;
        bool no_dots = false;
 
        while ((ch == '_') || (ch == ':'))
        {
          if (ch == '_')
            to_lower = true;
          else if (ch == ':')
            no_dots = true;
 
          ch = *src++;
        }
 
        /* use callback function to handle this case */
        *tmp = '\0';
        src = callback(tmp, sizeof(tmp), col, cols, ch, src, prefix, if_str,
                       else_str, data, flags);
 
        if (to_lower)
          mutt_str_lower(tmp);
        if (no_dots)
        {
          char *p = tmp;
          for (; *p; p++)
            if (*p == '.')
              *p = '_';
        }
 
        len = mutt_str_len(tmp);
        if ((len + wlen) > buflen)
          len = mutt_wstr_trunc(tmp, buflen - wlen, cols - col, NULL);
 
        memcpy(wptr, tmp, len);
        wptr += len;
        wlen += len;
        col += mutt_strwidth(tmp);
      }
    }
    else if (*src == '\\')
    {
      if (!*++src)
        break;
      switch (*src)
      {
        case 'f':
          *wptr = '\f';
          break;
        case 'n':
          *wptr = '\n';
          break;
        case 'r':
          *wptr = '\r';
          break;
        case 't':
          *wptr = '\t';
          break;
        case 'v':
          *wptr = '\v';
          break;
        default:
          *wptr = *src;
          break;
      }
      src++;
      wptr++;
      wlen++;
      col++;
    }
    else
    {
      int bytes, width;
      /* in case of error, simply copy byte */
      bytes = mutt_mb_charlen(src, &width);
      if (bytes < 0)
      {
        bytes = 1;
        width = 1;
      }
      if ((bytes > 0) && ((wlen + bytes) < buflen))
      {
        memcpy(wptr, src, bytes);
        wptr += bytes;
        src += bytes;
        wlen += bytes;
        col += width;
      }
      else
      {
        src += buflen - wlen;
        wlen = buflen;
      }
    }
  }
  *wptr = '\0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

crypt_format_str()

static const char * crypt_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the key selection menu - Implements format_t -.

Expando	Description
%n	Number
%p	Protocol
%t	Trust/validity of the key-uid association
%u	User id
%[fmt]	Date of key using strftime(3)

| | | %a | Algorithm | %c | Capabilities | %f | Flags | %i | Key fingerprint (or long key id if non-existent) | %k | Key id | %l | Length | | | %A | Algorithm of the principal key | %C | Capabilities of the principal key | %F | Flags of the principal key | %I | Key fingerprint of the principal key (or long key id if non-existent) | %K | Key id of the principal key | %L | Length of the principal key

Definition at line 317 of file dlg_gpgme.c.

{
  char fmt[128] = { 0 };
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  struct CryptEntry *entry = (struct CryptEntry *) data;
  struct CryptKeyInfo *key = entry->key;
 
  KeyFlags kflags = (key->flags);
 
  switch (tolower(op))
  {
    case 'a':
      if (!optional)
      {
        const char *s = NULL;
        snprintf(fmt, sizeof(fmt), "%%%s.3s", prec);
        if (key->kobj->subkeys)
          s = gpgme_pubkey_algo_name(key->kobj->subkeys->pubkey_algo);
        else
          s = "?";
        snprintf(buf, buflen, fmt, s);
      }
      break;
 
    case 'c':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, crypt_key_abilities(kflags));
      }
      else if (!(kflags & KEYFLAG_ABILITIES))
      {
        optional = false;
      }
      break;
 
    case 'f':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
        snprintf(buf, buflen, fmt, crypt_flags(kflags));
      }
      else if (!(kflags & KEYFLAG_RESTRICTIONS))
      {
        optional = false;
      }
      break;
 
    case 'i':
      if (!optional)
      {
        /* fixme: we need a way to distinguish between main and subkeys.
         * Store the idx in entry? */
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, crypt_fpr_or_lkeyid(key));
      }
      break;
 
    case 'k':
      if (!optional)
      {
        /* fixme: we need a way to distinguish between main and subkeys.
         * Store the idx in entry? */
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, crypt_keyid(key));
      }
      break;
 
    case 'l':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%slu", prec);
        unsigned long val;
        if (key->kobj->subkeys)
          val = key->kobj->subkeys->length;
        else
          val = 0;
        snprintf(buf, buflen, fmt, val);
      }
      break;
 
    case 'n':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, entry->num);
      }
      break;
 
    case 'p':
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, gpgme_get_protocol_name(key->kobj->protocol));
      break;
 
    case 't':
    {
      char *s = NULL;
      if ((kflags & KEYFLAG_ISX509))
      {
        s = "x";
      }
      else
      {
        switch (key->validity)
        {
          case GPGME_VALIDITY_FULL:
            s = "f";
            break;
          case GPGME_VALIDITY_MARGINAL:
            s = "m";
            break;
          case GPGME_VALIDITY_NEVER:
            s = "n";
            break;
          case GPGME_VALIDITY_ULTIMATE:
            s = "u";
            break;
          case GPGME_VALIDITY_UNDEFINED:
            s = "q";
            break;
          case GPGME_VALIDITY_UNKNOWN:
          default:
            s = "?";
            break;
        }
      }
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      snprintf(buf, buflen, fmt, *s);
      break;
    }
 
    case 'u':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, key->uid);
      }
      break;
 
    case '[':
    {
      char buf2[128];
      bool use_c_locale = false;
      struct tm tm = { 0 };
 
      char *p = buf;
 
      const char *cp = src;
      if (*cp == '!')
      {
        use_c_locale = true;
        cp++;
      }
 
      size_t len = buflen - 1;
      while ((len > 0) && (*cp != ']'))
      {
        if (*cp == '%')
        {
          cp++;
          if (len >= 2)
          {
            *p++ = '%';
            *p++ = *cp;
            len -= 2;
          }
          else
          {
            break; /* not enough space */
          }
          cp++;
        }
        else
        {
          *p++ = *cp++;
          len--;
        }
      }
      *p = '\0';
 
      if (key->kobj->subkeys && (key->kobj->subkeys->timestamp > 0))
        tm = mutt_date_localtime(key->kobj->subkeys->timestamp);
      else
        tm = mutt_date_localtime(0); // Default to 1970-01-01
 
      if (use_c_locale)
        strftime_l(buf2, sizeof(buf2), buf, &tm, NeoMutt->time_c_locale);
      else
        strftime(buf2, sizeof(buf2), buf, &tm);
 
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, buf2);
      if (len > 0)
        src = cp + 1;
      break;
    }
 
    default:
      *buf = '\0';
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, crypt_format_str, data,
                        MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, crypt_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_entry_format_str()

static const char * pgp_entry_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format an entry on the PGP key selection menu - Implements format_t -.

Expando	Description
%n	Number
%t	Trust/validity of the key-uid association
%u	User id
%[fmt]	Date of key using strftime(3)

| | | %a | Algorithm | %c | Capabilities | %f | Flags | %k | Key id | %l | Length | | | %A | Algorithm of the principal key | %C | Capabilities of the principal key | %F | Flags of the principal key | %K | Key id of the principal key | %L | Length of the principal key

Definition at line 282 of file dlg_pgp.c.

{
  char fmt[128] = { 0 };
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  struct PgpEntry *entry = (struct PgpEntry *) data;
  struct PgpUid *uid = entry->uid;
  struct PgpKeyInfo *key = uid->parent;
  struct PgpKeyInfo *pkey = pgp_principal_key(key);
 
  if (isupper((unsigned char) op))
    key = pkey;
 
  KeyFlags kflags = key->flags | (pkey->flags & KEYFLAG_RESTRICTIONS) | uid->flags;
 
  switch (tolower(op))
  {
    case 'a':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, key->algorithm);
      }
      break;
    case 'c':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, pgp_key_abilities(kflags));
      }
      else if (!(kflags & KEYFLAG_ABILITIES))
      {
        optional = false;
      }
      break;
    case 'f':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
        snprintf(buf, buflen, fmt, pgp_flags(kflags));
      }
      else if (!(kflags & KEYFLAG_RESTRICTIONS))
      {
        optional = false;
      }
      break;
    case 'k':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, pgp_this_keyid(key));
      }
      break;
    case 'l':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, key->keylen);
      }
      break;
    case 'n':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, entry->num);
      }
      break;
    case 't':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
        snprintf(buf, buflen, fmt, TrustFlags[uid->trust & 0x03]);
      }
      else if (!(uid->trust & 0x03))
      {
        /* undefined trust */
        optional = false;
      }
      break;
    case 'u':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(uid->addr));
      }
      break;
    case '[':
    {
      char buf2[128];
      bool use_c_locale = false;
      size_t len;
 
      char *p = buf;
 
      const char *cp = src;
      if (*cp == '!')
      {
        use_c_locale = true;
        cp++;
      }
 
      len = buflen - 1;
      while ((len > 0) && (*cp != ']'))
      {
        if (*cp == '%')
        {
          cp++;
          if (len >= 2)
          {
            *p++ = '%';
            *p++ = *cp;
            len -= 2;
          }
          else
          {
            break; /* not enough space */
          }
          cp++;
        }
        else
        {
          *p++ = *cp++;
          len--;
        }
      }
      *p = '\0';
 
      if (use_c_locale)
      {
        mutt_date_localtime_format_locale(buf2, sizeof(buf2), buf,
                                          key->gen_time, NeoMutt->time_c_locale);
      }
      else
      {
        mutt_date_localtime_format(buf2, sizeof(buf2), buf, key->gen_time);
      }
 
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, buf2);
      if (len > 0)
        src = cp + 1;
      break;
    }
    default:
      *buf = '\0';
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, pgp_entry_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, pgp_entry_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgp_command_format_str()

static const char * pgp_command_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a PGP command string - Implements format_t -.

Expando	Description
%a	Value of $pgp_sign_as if set, otherwise $pgp_default_key
%f	File containing a message
%p	Expands to PGPPASSFD=0 when a pass phrase is needed, to an empty string otherwise
%r	One or more key IDs (or fingerprints if available)
%s	File containing the signature part of a multipart/signed attachment when verifying it

Definition at line 80 of file pgpinvoke.c.

{
  char fmt[128] = { 0 };
  struct PgpCommandContext *cctx = (struct PgpCommandContext *) data;
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'a':
    {
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->signas));
      }
      else if (!cctx->signas)
      {
        optional = false;
      }
      break;
    }
    case 'f':
    {
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->fname));
      }
      else if (!cctx->fname)
      {
        optional = false;
      }
      break;
    }
    case 'p':
    {
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, cctx->need_passphrase ? "PGPPASSFD=0" : "");
      }
      else if (!cctx->need_passphrase || pgp_use_gpg_agent())
      {
        optional = false;
      }
      break;
    }
    case 'r':
    {
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->ids));
      }
      else if (!cctx->ids)
      {
        optional = false;
      }
      break;
    }
    case 's':
    {
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->sig_fname));
      }
      else if (!cctx->sig_fname)
      {
        optional = false;
      }
      break;
    }
    default:
    {
      *buf = '\0';
      break;
    }
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, pgp_command_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str,
                        pgp_command_format_str, data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smime_command_format_str()

static const char * smime_command_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format an SMIME command - Implements format_t -.

Expando	Description
%a	Algorithm used for encryption
%C	CA location: Depending on whether $smime_ca_location points to a directory or file
%c	One or more certificate IDs
%d	Message digest algorithm specified with $smime_sign_digest_alg
%f	File containing a message
%i	Intermediate certificates
%k	The key-pair specified with $smime_default_key
%s	File containing the signature part of a multipart/signed attachment when verifying it

Definition at line 224 of file smime.c.

{
  char fmt[128] = { 0 };
  struct SmimeCommandContext *cctx = (struct SmimeCommandContext *) data;
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'C':
    {
      const char *const c_smime_ca_location = cs_subset_path(NeoMutt->sub, "smime_ca_location");
      if (!optional)
      {
        struct Buffer *path = buf_pool_get();
        struct Buffer *buf1 = buf_pool_get();
        struct Buffer *buf2 = buf_pool_get();
        struct stat st = { 0 };
 
        buf_strcpy(path, c_smime_ca_location);
        buf_expand_path(path);
        buf_quote_filename(buf1, buf_string(path), true);
 
        if ((stat(buf_string(path), &st) != 0) || !S_ISDIR(st.st_mode))
          buf_printf(buf2, "-CAfile %s", buf_string(buf1));
        else
          buf_printf(buf2, "-CApath %s", buf_string(buf1));
 
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, buf_string(buf2));
 
        buf_pool_release(&path);
        buf_pool_release(&buf1);
        buf_pool_release(&buf2);
      }
      else if (!c_smime_ca_location)
      {
        optional = false;
      }
      break;
    }
 
    case 'c':
    { /* certificate (list) */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->certificates));
      }
      else if (!cctx->certificates)
      {
        optional = false;
      }
      break;
    }
 
    case 'i':
    { /* intermediate certificates  */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->intermediates));
      }
      else if (!cctx->intermediates)
      {
        optional = false;
      }
      break;
    }
 
    case 's':
    { /* detached signature */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->sig_fname));
      }
      else if (!cctx->sig_fname)
      {
        optional = false;
      }
      break;
    }
 
    case 'k':
    { /* private key */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->key));
      }
      else if (!cctx->key)
      {
        optional = false;
      }
      break;
    }
 
    case 'a':
    { /* algorithm for encryption */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->cryptalg));
      }
      else if (!cctx->key)
      {
        optional = false;
      }
      break;
    }
 
    case 'f':
    { /* file to process */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->fname));
      }
      else if (!cctx->fname)
      {
        optional = false;
      }
      break;
    }
 
    case 'd':
    { /* algorithm for the signature message digest */
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, NONULL(cctx->digestalg));
      }
      else if (!cctx->key)
      {
        optional = false;
      }
      break;
    }
 
    default:
      *buf = '\0';
      break;
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str,
                        smime_command_format_str, data, MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str,
                        smime_command_format_str, data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

group_index_format_str()

const char * group_index_format_str	(	char *	buf,
		size_t	buflen,
		size_t	col,
		int	cols,
		char	op,
		const char *	src,
		const char *	prec,
		const char *	if_str,
		const char *	else_str,
		intptr_t	data,
		MuttFormatFlags	flags
	)

Format a string for the newsgroup menu - Implements format_t -.

Expando	Description
%a	Alert: 1 if user is notified of new mail
%C	Current newsgroup number
%d	Description of newsgroup (becomes from server)
%f	Newsgroup name
%M	- if newsgroup not allowed for direct post (moderated for example)
%N	N if newsgroup is new, u if unsubscribed, blank otherwise
%n	Number of new articles in newsgroup
%p	Poll: 1 if Mailbox is checked for new mail
%s	Number of unread articles in newsgroup

Definition at line 57 of file browse.c.

{
  char fn[128], fmt[128];
  struct Folder *folder = (struct Folder *) data;
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'a':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->notify_user);
      }
      else
      {
        if (folder->ff->notify_user == 0)
          optional = false;
      }
      break;
 
    case 'C':
      snprintf(fmt, sizeof(fmt), "%%%sd", prec);
      snprintf(buf, buflen, fmt, folder->num + 1);
      break;
 
    case 'd':
      if (folder->ff->nd->desc)
      {
        char *desc = mutt_str_dup(folder->ff->nd->desc);
        const char *const c_newsgroups_charset = cs_subset_string(NeoMutt->sub, "newsgroups_charset");
        if (c_newsgroups_charset)
          mutt_ch_convert_string(&desc, c_newsgroups_charset, cc_charset(), MUTT_ICONV_HOOK_FROM);
        mutt_mb_filter_unprintable(&desc);
 
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, desc);
        FREE(&desc);
      }
      else
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, "");
      }
      break;
 
    case 'f':
      mutt_str_copy(fn, folder->ff->name, sizeof(fn));
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, fn);
      break;
 
    case 'M':
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      if (folder->ff->nd->deleted)
        snprintf(buf, buflen, fmt, 'D');
      else
        snprintf(buf, buflen, fmt, folder->ff->nd->allowed ? ' ' : '-');
      break;
 
    case 'N':
      snprintf(fmt, sizeof(fmt), "%%%sc", prec);
      if (folder->ff->nd->subscribed)
        snprintf(buf, buflen, fmt, ' ');
      else
        snprintf(buf, buflen, fmt, folder->ff->has_new_mail ? 'N' : 'u');
      break;
 
    case 'n':
    {
      const bool c_mark_old = cs_subset_bool(NeoMutt->sub, "mark_old");
      if (c_mark_old && (folder->ff->nd->last_cached >= folder->ff->nd->first_message) &&
          (folder->ff->nd->last_cached <= folder->ff->nd->last_message))
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->nd->last_message - folder->ff->nd->last_cached);
      }
      else
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->nd->unread);
      }
      break;
    }
 
    case 'p':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->poll_new_mail);
      }
      else
      {
        if (folder->ff->poll_new_mail == 0)
          optional = false;
      }
      break;
 
    case 's':
      if (optional)
      {
        if (folder->ff->nd->unread != 0)
        {
          mutt_expando_format(buf, buflen, col, cols, if_str,
                              group_index_format_str, data, flags);
        }
        else
        {
          mutt_expando_format(buf, buflen, col, cols, else_str,
                              group_index_format_str, data, flags);
        }
      }
      else
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, folder->ff->nd->unread);
      }
      break;
  }
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nntp_format_str()

const char * nntp_format_str	(	char *	buf,
		size_t	buflen,
		size_t	col,
		int	cols,
		char	op,
		const char *	src,
		const char *	prec,
		const char *	if_str,
		const char *	else_str,
		intptr_t	data,
		MuttFormatFlags	flags
	)

Expand the newsrc filename - Implements format_t -.

Expando	Description
%a	Account url
%p	Port
%P	Port if specified
%s	News server name
%S	Url schema
%u	Username

Definition at line 927 of file newsrc.c.

{
  struct NntpAccountData *adata = (struct NntpAccountData *) data;
  struct ConnAccount *cac = &adata->conn->account;
  char fn[128], fmt[128];
 
  switch (op)
  {
    case 'a':
    {
      struct Url url = { 0 };
      mutt_account_tourl(cac, &url);
      url_tostring(&url, fn, sizeof(fn), U_PATH);
      char *p = strchr(fn, '/');
      if (p)
        *p = '\0';
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, fn);
      break;
    }
    case 'p':
      snprintf(fmt, sizeof(fmt), "%%%su", prec);
      snprintf(buf, buflen, fmt, cac->port);
      break;
    case 'P':
      *buf = '\0';
      if (cac->flags & MUTT_ACCT_PORT)
      {
        snprintf(fmt, sizeof(fmt), "%%%su", prec);
        snprintf(buf, buflen, fmt, cac->port);
      }
      break;
    case 's':
      mutt_str_copy(fn, cac->host, sizeof(fn));
      mutt_str_lower(fn);
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, fn);
      break;
    case 'S':
    {
      struct Url url = { 0 };
      mutt_account_tourl(cac, &url);
      url_tostring(&url, fn, sizeof(fn), U_PATH);
      char *p = strchr(fn, ':');
      if (p)
        *p = '\0';
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, fn);
      break;
    }
    case 'u':
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, cac->user);
      break;
  }
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pattern_format_str()

static const char * pattern_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the pattern completion menu - Implements format_t -.

Expando	Description
%d	Pattern description
%e	Pattern expression
%n	Index number

Definition at line 106 of file dlg_pattern.c.

{
  struct PatternEntry *entry = (struct PatternEntry *) data;
 
  switch (op)
  {
    case 'd':
      mutt_format_s(buf, buflen, prec, NONULL(entry->desc));
      break;
    case 'e':
      mutt_format_s(buf, buflen, prec, NONULL(entry->expr));
      break;
    case 'n':
    {
      char tmp[32] = { 0 };
      snprintf(tmp, sizeof(tmp), "%%%sd", prec);
      snprintf(buf, buflen, tmp, entry->num);
      break;
    }
  }
 
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

greeting_format_str()

static const char * greeting_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a greetings string - Implements format_t -.

Expando	Description
%n	Recipient's real name (or address if missing)
%u	User (login) name of the recipient
%v	First name of the recipient

Definition at line 682 of file send.c.

{
  struct Email *e = (struct Email *) data;
  char *p = NULL;
  char buf2[256];
 
  const struct Address *to = TAILQ_FIRST(&e->env->to);
  const struct Address *cc = TAILQ_FIRST(&e->env->cc);
 
  buf[0] = '\0';
  switch (op)
  {
    case 'n':
      mutt_format_s(buf, buflen, prec, mutt_get_name(to));
      break;
 
    case 'u':
      if (to)
      {
        mutt_str_copy(buf2, mutt_addr_for_display(to), sizeof(buf2));
        if ((p = strpbrk(buf2, "%@")))
          *p = '\0';
      }
      else
      {
        buf2[0] = '\0';
      }
      mutt_format_s(buf, buflen, prec, buf2);
      break;
 
    case 'v':
      if (to)
        mutt_format_s(buf2, sizeof(buf2), prec, mutt_get_name(to));
      else if (cc)
        mutt_format_s(buf2, sizeof(buf2), prec, mutt_get_name(cc));
      else
        *buf2 = '\0';
      if ((p = strpbrk(buf2, " %@")))
        *p = '\0';
      mutt_format_s(buf, buflen, prec, buf2);
      break;
 
    default:
      snprintf(buf, buflen, "%%%s%c", prec, op);
      break;
  }
 
  if (flags & MUTT_FORMAT_OPTIONAL)
    mutt_expando_format(buf, buflen, col, cols, else_str, greeting_format_str, data, flags);
 
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sidebar_format_str()

static const char * sidebar_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Format a string for the sidebar - Implements format_t -.

Expando	Description
%!	'n!' Flagged messages
%a	Alert: 1 if user is notified of new mail
%B	Name of the mailbox
%D	Description of the mailbox
%d	Number of deleted messages
%F	Number of Flagged messages in the mailbox
%L	Number of messages after limiting
%n	"N" if mailbox has new mail, " " (space) otherwise
%N	Number of unread messages in the mailbox
%o	Number of old unread messages in the mailbox
%p	Poll: 1 if Mailbox is checked for new mail
%r	Number of read messages in the mailbox
%S	Size of mailbox (total number of messages)
%t	Number of tagged messages
%Z	Number of new unseen messages in the mailbox

Definition at line 350 of file window.c.

{
  struct SidebarFormatData *sfdata = (struct SidebarFormatData *) data;
  struct SbEntry *sbe = sfdata->entry;
  struct IndexSharedData *shared = sfdata->shared;
  char fmt[256] = { 0 };
 
  if (!sbe || !shared || !buf)
    return src;
 
  buf[0] = '\0'; /* Just in case there's nothing to do */
 
  struct Mailbox *m = sbe->mailbox;
  if (!m)
    return src;
 
  struct Mailbox *m_cur = shared->mailbox;
 
  bool c = m_cur && mutt_str_equal(m_cur->realpath, m->realpath);
 
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
 
  switch (op)
  {
    case 'a':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->notify_user);
      }
      else
      {
        if (m->notify_user == 0)
          optional = false;
      }
      break;
 
    case 'B':
    case 'D':
    {
      char indented[256] = { 0 };
      size_t ilen = sizeof(indented);
      size_t off = add_indent(indented, ilen, sbe);
      snprintf(indented + off, ilen - off, "%s",
               ((op == 'D') && sbe->mailbox->name) ? sbe->mailbox->name : sbe->box);
      mutt_format_s(buf, buflen, prec, indented);
      break;
    }
 
    case 'd':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, c ? m_cur->msg_deleted : 0);
      }
      else if ((c && (m_cur->msg_deleted == 0)) || !c)
      {
        optional = false;
      }
      break;
 
    case 'F':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_flagged);
      }
      else if (m->msg_flagged == 0)
      {
        optional = false;
      }
      break;
 
    case 'L':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, c ? m_cur->vcount : m->msg_count);
      }
      else if ((c && (m_cur->vcount == m->msg_count)) || !c)
      {
        optional = false;
      }
      break;
 
    case 'N':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_unread);
      }
      else if (m->msg_unread == 0)
      {
        optional = false;
      }
      break;
 
    case 'n':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sc", prec);
        snprintf(buf, buflen, fmt, m->has_new ? 'N' : ' ');
      }
      else if (m->has_new == false)
      {
        optional = false;
      }
      break;
 
    case 'o':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_unread - m->msg_new);
      }
      else if ((c && (m_cur->msg_unread - m_cur->msg_new) == 0) || !c)
      {
        optional = false;
      }
      break;
 
    case 'p':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->poll_new_mail);
      }
      else
      {
        if (m->poll_new_mail == 0)
          optional = false;
      }
      break;
 
    case 'r':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_count - m->msg_unread);
      }
      else if ((c && (m_cur->msg_count - m_cur->msg_unread) == 0) || !c)
      {
        optional = false;
      }
      break;
 
    case 'S':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_count);
      }
      else if (m->msg_count == 0)
      {
        optional = false;
      }
      break;
 
    case 't':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, c ? m_cur->msg_tagged : 0);
      }
      else if ((c && (m_cur->msg_tagged == 0)) || !c)
      {
        optional = false;
      }
      break;
 
    case 'Z':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m->msg_new);
      }
      else if ((c && (m_cur->msg_new) == 0) || !c)
      {
        optional = false;
      }
      break;
 
    case '!':
      if (m->msg_flagged == 0)
      {
        mutt_format_s(buf, buflen, prec, "");
      }
      else if (m->msg_flagged == 1)
      {
        mutt_format_s(buf, buflen, prec, "!");
      }
      else if (m->msg_flagged == 2)
      {
        mutt_format_s(buf, buflen, prec, "!!");
      }
      else
      {
        snprintf(fmt, sizeof(fmt), "%d!", m->msg_flagged);
        mutt_format_s(buf, buflen, prec, fmt);
      }
      break;
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, sidebar_format_str, data, flags);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, sidebar_format_str, data, flags);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

status_format_str()

static const char * status_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Create the status bar string - Implements format_t -.

Expando	Description
%b	Number of incoming folders with unread messages
%D	Description of the mailbox
%d	Number of deleted messages
%f	Full mailbox path
%F	Number of flagged messages
%h	Hostname
%l	Length of mailbox (in bytes)
%L	Size (in bytes) of the messages shown (or limited)
%M	Number of messages shown (virtual message count when limiting)
%m	Total number of messages
%n	Number of new messages
%o	Number of old unread messages
%p	Number of postponed messages
%P	Percent of way through index
%R	Number of read messages
%r	Readonly/wontwrite/changed flag
%S	Current aux sorting method ($sort_aux)
%s	Current sorting method ($sort)
%T	Current threading view ($use_threads)
%t	Number of tagged messages
%u	Number of unread messages
%V	Currently active limit pattern
%v	NeoMutt version

Definition at line 100 of file status.c.

{
  char fmt[128], tmp[128];
  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
  struct MenuStatusLineData *msld = (struct MenuStatusLineData *) data;
  struct IndexSharedData *shared = msld->shared;
  struct MailboxView *mv = shared->mailbox_view;
  struct Mailbox *m = shared->mailbox;
  struct Menu *menu = msld->menu;
 
  *buf = '\0';
  switch (op)
  {
    case 'b':
    {
      const int num = mutt_mailbox_check(m, MUTT_MAILBOX_CHECK_NO_FLAGS);
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, num);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'd':
    {
      const int num = m ? m->msg_deleted : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, num);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'D':
      // If there's a descriptive name, use it. Otherwise, fall-through
      if (m && m->name)
      {
        mutt_str_copy(tmp, m->name, sizeof(tmp));
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, tmp);
        break;
      }
    /* fallthrough */
    case 'f':
#ifdef USE_COMP_MBOX
      if (m && m->compress_info && (m->realpath[0] != '\0'))
      {
        mutt_str_copy(tmp, m->realpath, sizeof(tmp));
        mutt_pretty_mailbox(tmp, sizeof(tmp));
      }
      else
#endif
          if (m && (m->type == MUTT_NOTMUCH) && m->name)
      {
        mutt_str_copy(tmp, m->name, sizeof(tmp));
      }
      else if (m && !buf_is_empty(&m->pathbuf))
      {
        mutt_str_copy(tmp, mailbox_path(m), sizeof(tmp));
        mutt_pretty_mailbox(tmp, sizeof(tmp));
      }
      else
      {
        mutt_str_copy(tmp, _("(no mailbox)"), sizeof(tmp));
      }
 
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, tmp);
      break;
    case 'F':
    {
      const int num = m ? m->msg_flagged : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, num);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'h':
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, NONULL(ShortHostname));
      break;
 
    case 'l':
    {
      const off_t num = m ? m->size : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        mutt_str_pretty_size(tmp, sizeof(tmp), num);
        snprintf(buf, buflen, fmt, tmp);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'L':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        mutt_str_pretty_size(tmp, sizeof(tmp), mv ? mv->vsize : 0);
        snprintf(buf, buflen, fmt, tmp);
      }
      else if (!mview_has_limit(mv))
      {
        optional = false;
      }
      break;
 
    case 'm':
    {
      const int num = m ? m->msg_count : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, num);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'M':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m ? m->vcount : 0);
      }
      else if (!mview_has_limit(mv))
      {
        optional = false;
      }
      break;
 
    case 'n':
    {
      const int num = m ? m->msg_new : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, num);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'o':
    {
      const int num = m ? (m->msg_unread - m->msg_new) : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, num);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'p':
    {
      const int count = mutt_num_postponed(m, false);
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, count);
      }
      else if (count == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'P':
    {
      if (!menu)
        break;
      char *cp = NULL;
      if (menu->top + menu->page_len >= menu->max)
      {
        cp = menu->top ?
                 /* L10N: Status bar message: the end of the list emails is visible in the index */
                 _("end") :
                 /* L10N: Status bar message: all the emails are visible in the index */
                 _("all");
      }
      else
      {
        int count = (100 * (menu->top + menu->page_len)) / menu->max;
        /* L10N: Status bar, percentage of way through index.
           `%d` is the number, `%%` is the percent symbol.
           They may be reordered, or space inserted, if you wish. */
        snprintf(tmp, sizeof(tmp), _("%d%%"), count);
        cp = tmp;
      }
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      snprintf(buf, buflen, fmt, cp);
      break;
    }
 
    case 'r':
    {
      size_t i = 0;
 
      if (m)
      {
        i = shared->attach_msg ? 3 :
                                 ((m->readonly || m->dontwrite) ? 2 :
                                  (m->changed ||
                                   /* deleted doesn't necessarily mean changed in IMAP */
                                   (m->type != MUTT_IMAP && m->msg_deleted)) ?
                                                                  1 :
                                                                  0);
      }
 
      const struct MbTable *c_status_chars = cs_subset_mbtable(NeoMutt->sub, "status_chars");
      if (!c_status_chars || !c_status_chars->len)
        buf[0] = '\0';
      else if (i >= c_status_chars->len)
        snprintf(buf, buflen, "%s", c_status_chars->chars[0]);
      else
        snprintf(buf, buflen, "%s", c_status_chars->chars[i]);
      break;
    }
 
    case 'R':
    {
      const int read = m ? (m->msg_count - m->msg_unread) : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, read);
      }
      else if (read == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 's':
    {
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      const enum SortType c_sort = cs_subset_sort(NeoMutt->sub, "sort");
      snprintf(buf, buflen, fmt, get_sort_str(tmp, sizeof(tmp), c_sort));
      break;
    }
 
    case 'S':
    {
      snprintf(fmt, sizeof(fmt), "%%%ss", prec);
      const enum SortType c_sort_aux = cs_subset_sort(NeoMutt->sub, "sort_aux");
      snprintf(buf, buflen, fmt, get_sort_str(tmp, sizeof(tmp), c_sort_aux));
      break;
    }
 
    case 't':
    {
      const int num = m ? m->msg_tagged : 0;
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, num);
      }
      else if (num == 0)
      {
        optional = false;
      }
      break;
    }
 
    case 'T':
    {
      const enum UseThreads c_use_threads = mutt_thread_style();
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, get_use_threads_str(c_use_threads));
      }
      else if (c_use_threads == UT_FLAT)
      {
        optional = false;
      }
      break;
    }
 
    case 'u':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%sd", prec);
        snprintf(buf, buflen, fmt, m ? m->msg_unread : 0);
      }
      else if (!m || (m->msg_unread == 0))
      {
        optional = false;
      }
      break;
 
    case 'v':
      snprintf(buf, buflen, "%s", mutt_make_version());
      break;
 
    case 'V':
      if (!optional)
      {
        snprintf(fmt, sizeof(fmt), "%%%ss", prec);
        snprintf(buf, buflen, fmt, mview_has_limit(mv) ? mv->pattern : "");
      }
      else if (!mview_has_limit(mv))
      {
        optional = false;
      }
      break;
 
    case 0:
      *buf = '\0';
      return src;
 
    default:
      snprintf(buf, buflen, "%%%s%c", prec, op);
      break;
  }
 
  if (optional)
  {
    mutt_expando_format(buf, buflen, col, cols, if_str, status_format_str, data,
                        MUTT_FORMAT_NO_FLAGS);
  }
  else if (flags & MUTT_FORMAT_OPTIONAL)
  {
    mutt_expando_format(buf, buflen, col, cols, else_str, status_format_str,
                        data, MUTT_FORMAT_NO_FLAGS);
  }
 
  /* We return the format string, unchanged */
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function: