NeoMutt  2020-11-20
Teaching an old dog new tricks
DOXYGEN
hdrline.c File Reference

String processing routines to generate the mail index. More...

#include "config.h"
#include <locale.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "gui/lib.h"
#include "hdrline.h"
#include "ncrypt/lib.h"
#include "context.h"
#include "format_flags.h"
#include "hook.h"
#include "maillist.h"
#include "mutt_globals.h"
#include "mutt_menu.h"
#include "mutt_parse.h"
#include "mutt_thread.h"
#include "muttlib.h"
#include "sort.h"
#include "notmuch/lib.h"
+ Include dependency graph for hdrline.c:

Go to the source code of this file.

Enumerations

enum  FlagChars {
  FLAG_CHAR_TAGGED, FLAG_CHAR_IMPORTANT, FLAG_CHAR_DELETED, FLAG_CHAR_DELETED_ATTACH,
  FLAG_CHAR_REPLIED, FLAG_CHAR_OLD, FLAG_CHAR_NEW, FLAG_CHAR_OLD_THREAD,
  FLAG_CHAR_NEW_THREAD, FLAG_CHAR_SEMPTY, FLAG_CHAR_ZEMPTY
}
 Index into the $flag_chars variable ($flag_chars) More...
 
enum  CryptChars {
  FLAG_CHAR_CRYPT_GOOD_SIGN, FLAG_CHAR_CRYPT_ENCRYPTED, FLAG_CHAR_CRYPT_SIGNED, FLAG_CHAR_CRYPT_CONTAINS_KEY,
  FLAG_CHAR_CRYPT_NO_CRYPTO
}
 Index into the $crypt_chars variable ($crypt_chars) More...
 
enum  FieldType {
  DISP_TO, DISP_CC, DISP_BCC, DISP_FROM,
  DISP_PLAIN, DISP_MAX
}
 Header types. More...
 

Functions

static size_t add_index_color (char *buf, size_t buflen, MuttFormatFlags flags, char color)
 Insert a color marker into a string. More...
 
static const char * get_nth_wchar (struct MbTable *table, int index)
 Extract one char from a multi-byte table. More...
 
static const char * make_from_prefix (enum FieldType disp)
 Create a prefix for an author field. More...
 
static void make_from (struct Envelope *env, char *buf, size_t buflen, bool do_lists, MuttFormatFlags flags)
 Generate a From: field (with optional prefix) More...
 
static void make_from_addr (struct Envelope *env, char *buf, size_t buflen, bool do_lists)
 Create a 'from' address for a reply email. More...
 
static bool user_in_addr (struct AddressList *al)
 Do any of the addresses refer to the user? More...
 
static int user_is_recipient (struct Email *e)
 Is the user a recipient of the message. More...
 
static char * apply_subject_mods (struct Envelope *env)
 Apply regex modifications to the subject. More...
 
static bool thread_is_new (struct Email *e)
 Does the email thread contain any new emails? More...
 
static bool thread_is_old (struct Email *e)
 Does the email thread contain any unread emails? More...
 
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. More...
 
void mutt_make_string_flags (char *buf, size_t buflen, int cols, const char *s, struct Mailbox *m, int inpgr, struct Email *e, MuttFormatFlags flags)
 Create formatted strings using mailbox expandos. More...
 
void mutt_make_string_info (char *buf, size_t buflen, int cols, const char *s, struct HdrFormatInfo *hfi, MuttFormatFlags flags)
 Create pager status bar string. More...
 

Variables

struct MbTableC_CryptChars
 Config: User-configurable crypto flags: signed, encrypted etc. More...
 
struct MbTableC_FlagChars
 Config: User-configurable index flags: tagged, new, etc. More...
 
struct MbTableC_FromChars
 Config: User-configurable index flags: to address, cc address, etc. More...
 
struct MbTableC_ToChars
 Config: Indicator characters for the 'To' field in the index. More...
 

Detailed Description

String processing routines to generate the mail index.

Authors
  • Michael R. Elkins
  • Richard Russon
  • Ian Zimmerman
  • Pietro Cerutti

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file hdrline.c.

Enumeration Type Documentation

◆ FlagChars

enum FlagChars

Index into the $flag_chars variable ($flag_chars)

Enumerator
FLAG_CHAR_TAGGED 

Character denoting a tagged email.

FLAG_CHAR_IMPORTANT 

Character denoting a important (flagged) email.

FLAG_CHAR_DELETED 

Character denoting a deleted email.

FLAG_CHAR_DELETED_ATTACH 

Character denoting a deleted attachment.

FLAG_CHAR_REPLIED 

Character denoting an email that has been replied to.

FLAG_CHAR_OLD 

Character denoting an email that has been read.

FLAG_CHAR_NEW 

Character denoting an unread email.

FLAG_CHAR_OLD_THREAD 

Character denoting a thread of emails that has been read.

FLAG_CHAR_NEW_THREAD 

Character denoting a thread containing at least one new email.

FLAG_CHAR_SEMPTY 

Character denoting a read email, $index_format S expando.

FLAG_CHAR_ZEMPTY 

Character denoting a read email, $index_format Z expando.

Definition at line 72 of file hdrline.c.

73 {
85 };
Character denoting a tagged email.
Definition: hdrline.c:74
Character denoting a important (flagged) email.
Definition: hdrline.c:75
Character denoting a thread containing at least one new email.
Definition: hdrline.c:82
Character denoting a read email, $index_format S expando.
Definition: hdrline.c:83
Character denoting a deleted attachment.
Definition: hdrline.c:77
Character denoting an email that has been read.
Definition: hdrline.c:79
Character denoting a thread of emails that has been read.
Definition: hdrline.c:81
Character denoting an email that has been replied to.
Definition: hdrline.c:78
Character denoting a read email, $index_format Z expando.
Definition: hdrline.c:84
Character denoting a deleted email.
Definition: hdrline.c:76
Character denoting an unread email.
Definition: hdrline.c:80

◆ CryptChars

enum CryptChars

Index into the $crypt_chars variable ($crypt_chars)

Enumerator
FLAG_CHAR_CRYPT_GOOD_SIGN 

Character denoting a message signed with a verified key.

FLAG_CHAR_CRYPT_ENCRYPTED 

Character denoting a message is PGP-encrypted.

FLAG_CHAR_CRYPT_SIGNED 

Character denoting a message is signed.

FLAG_CHAR_CRYPT_CONTAINS_KEY 

Character denoting a message contains a PGP key.

FLAG_CHAR_CRYPT_NO_CRYPTO 

Character denoting a message has no cryptography information.

Definition at line 90 of file hdrline.c.

91 {
97 };
Character denoting a message contains a PGP key.
Definition: hdrline.c:95
Character denoting a message signed with a verified key.
Definition: hdrline.c:92
Character denoting a message is PGP-encrypted.
Definition: hdrline.c:93
Character denoting a message has no cryptography information.
Definition: hdrline.c:96
Character denoting a message is signed.
Definition: hdrline.c:94

◆ FieldType

enum FieldType

Header types.

Strings for printing headers

Enumerator
DISP_TO 

To: string.

DISP_CC 

Cc: string.

DISP_BCC 

Bcc: string.

DISP_FROM 

From: string.

DISP_PLAIN 

Empty string.

DISP_MAX 

Definition at line 104 of file hdrline.c.

105 {
106  DISP_TO,
107  DISP_CC,
108  DISP_BCC,
109  DISP_FROM,
110  DISP_PLAIN,
111  DISP_MAX,
112 };
Bcc: string.
Definition: hdrline.c:108
Cc: string.
Definition: hdrline.c:107
Empty string.
Definition: hdrline.c:110
From: string.
Definition: hdrline.c:109
To: string.
Definition: hdrline.c:106

Function Documentation

◆ add_index_color()

static size_t add_index_color ( char *  buf,
size_t  buflen,
MuttFormatFlags  flags,
char  color 
)
static

Insert a color marker into a string.

Parameters
bufBuffer to store marker
buflenBuffer length
flagsFlags, see MuttFormatFlags
colorColor, e.g. MT_COLOR_MESSAGE
Return values
numCharacters written

The colors are stored as "magic" strings embedded in the text.

Definition at line 124 of file hdrline.c.

125 {
126  /* only add color markers if we are operating on main index entries. */
127  if (!(flags & MUTT_FORMAT_INDEX))
128  return 0;
129 
130  /* this item is going to be passed to an external filter */
131  if (flags & MUTT_FORMAT_NOFILTER)
132  return 0;
133 
134  if (color == MT_COLOR_INDEX)
135  { /* buf might be uninitialized other cases */
136  const size_t len = mutt_str_len(buf);
137  buf += len;
138  buflen -= len;
139  }
140 
141  if (buflen <= 2)
142  return 0;
143 
144  buf[0] = MUTT_SPECIAL_INDEX;
145  buf[1] = color;
146  buf[2] = '\0';
147 
148  return 2;
149 }
#define MUTT_FORMAT_INDEX
This is a main index entry.
Definition: format_flags.h:36
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:631
Colour indicator.
Definition: mutt_thread.h:71
#define MUTT_FORMAT_NOFILTER
Do not allow filtering on this pass.
Definition: format_flags.h:37
Index: default colour (takes a pattern)
Definition: color.h:100
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_nth_wchar()

static const char* get_nth_wchar ( struct MbTable table,
int  index 
)
static

Extract one char from a multi-byte table.

Parameters
tableMulti-byte table
indexSelect this character
Return values
ptrString pointer to the character

Extract one multi-byte character from a string table. If the index is invalid, then a space character will be returned. If the character selected is '
' (Ctrl-M), then "" will be returned.

Definition at line 161 of file hdrline.c.

162 {
163  if (!table || !table->chars || (index < 0) || (index >= table->len))
164  return " ";
165 
166  if (table->chars[index][0] == '\r')
167  return "";
168 
169  return table->chars[index];
170 }
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
int len
Number of characters.
Definition: mbtable.h:38
+ Here is the caller graph for this function:

◆ make_from_prefix()

static const char* make_from_prefix ( enum FieldType  disp)
static

Create a prefix for an author field.

Parameters
dispType of field
Return values
ptrPrefix string (do not free it)

If $from_chars is set, pick an appropriate character from it. If not, use the default prefix: "To", "Cc", etc

Definition at line 180 of file hdrline.c.

181 {
182  /* need 2 bytes at the end, one for the space, another for NUL */
183  static char padded[8];
184  static const char *long_prefixes[DISP_MAX] = {
185  [DISP_TO] = "To ", [DISP_CC] = "Cc ", [DISP_BCC] = "Bcc ",
186  [DISP_FROM] = "", [DISP_PLAIN] = "",
187  };
188 
189  if (!C_FromChars || !C_FromChars->chars || (C_FromChars->len == 0))
190  return long_prefixes[disp];
191 
192  const char *pchar = get_nth_wchar(C_FromChars, disp);
193  if (mutt_str_len(pchar) == 0)
194  return "";
195 
196  snprintf(padded, sizeof(padded), "%s ", pchar);
197  return padded;
198 }
Bcc: string.
Definition: hdrline.c:108
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
Cc: string.
Definition: hdrline.c:107
struct MbTable * C_FromChars
Config: User-configurable index flags: to address, cc address, etc.
Definition: hdrline.c:66
Empty string.
Definition: hdrline.c:110
From: string.
Definition: hdrline.c:109
static const char * get_nth_wchar(struct MbTable *table, int index)
Extract one char from a multi-byte table.
Definition: hdrline.c:161
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:631
To: string.
Definition: hdrline.c:106
int len
Number of characters.
Definition: mbtable.h:38
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ make_from()

static void make_from ( struct Envelope env,
char *  buf,
size_t  buflen,
bool  do_lists,
MuttFormatFlags  flags 
)
static

Generate a From: field (with optional prefix)

Parameters
envEnvelope of the email
bufBuffer to store the result
buflenSize of the buffer
do_listsShould we check for mailing lists?
flagsFormat flags, see MuttFormatFlags

Generate the F or L field in $index_format. This is the author, or recipient of the email.

The field can optionally be prefixed by a character from $from_chars. If $from_chars is not set, the prefix will be, "To", "Cc", etc

Definition at line 214 of file hdrline.c.

216 {
217  if (!env || !buf)
218  return;
219 
220  bool me;
221  enum FieldType disp;
222  struct AddressList *name = NULL;
223 
224  me = mutt_addr_is_user(TAILQ_FIRST(&env->from));
225 
226  if (do_lists || me)
227  {
228  if (check_for_mailing_list(&env->to, make_from_prefix(DISP_TO), buf, buflen))
229  return;
230  if (check_for_mailing_list(&env->cc, make_from_prefix(DISP_CC), buf, buflen))
231  return;
232  }
233 
234  if (me && !TAILQ_EMPTY(&env->to))
235  {
236  disp = (flags & MUTT_FORMAT_PLAIN) ? DISP_PLAIN : DISP_TO;
237  name = &env->to;
238  }
239  else if (me && !TAILQ_EMPTY(&env->cc))
240  {
241  disp = DISP_CC;
242  name = &env->cc;
243  }
244  else if (me && !TAILQ_EMPTY(&env->bcc))
245  {
246  disp = DISP_BCC;
247  name = &env->bcc;
248  }
249  else if (!TAILQ_EMPTY(&env->from))
250  {
251  disp = DISP_FROM;
252  name = &env->from;
253  }
254  else
255  {
256  *buf = '\0';
257  return;
258  }
259 
260  snprintf(buf, buflen, "%s%s", make_from_prefix(disp), mutt_get_name(TAILQ_FIRST(name)));
261 }
Bcc: string.
Definition: hdrline.c:108
#define TAILQ_FIRST(head)
Definition: queue.h:716
struct AddressList bcc
Email&#39;s &#39;Bcc&#39; list.
Definition: envelope.h:60
Cc: string.
Definition: hdrline.c:107
bool check_for_mailing_list(struct AddressList *al, const char *pfx, char *buf, int buflen)
Search list of addresses for a mailing list.
Definition: maillist.c:79
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
Empty string.
Definition: hdrline.c:110
From: string.
Definition: hdrline.c:109
static const char * make_from_prefix(enum FieldType disp)
Create a prefix for an author field.
Definition: hdrline.c:180
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
To: string.
Definition: hdrline.c:106
FieldType
Header types.
Definition: hdrline.c:104
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:547
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:714
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:157
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ make_from_addr()

static void make_from_addr ( struct Envelope env,
char *  buf,
size_t  buflen,
bool  do_lists 
)
static

Create a 'from' address for a reply email.

Parameters
envEnvelope of current email
bufBuffer for the result
buflenLength of buffer
do_listsIf true, check for mailing lists

Definition at line 270 of file hdrline.c.

271 {
272  if (!env || !buf)
273  return;
274 
275  bool me = mutt_addr_is_user(TAILQ_FIRST(&env->from));
276 
277  if (do_lists || me)
278  {
279  if (check_for_mailing_list_addr(&env->to, buf, buflen))
280  return;
281  if (check_for_mailing_list_addr(&env->cc, buf, buflen))
282  return;
283  }
284 
285  if (me && !TAILQ_EMPTY(&env->to))
286  snprintf(buf, buflen, "%s", TAILQ_FIRST(&env->to)->mailbox);
287  else if (me && !TAILQ_EMPTY(&env->cc))
288  snprintf(buf, buflen, "%s", TAILQ_FIRST(&env->cc)->mailbox);
289  else if (!TAILQ_EMPTY(&env->from))
290  mutt_str_copy(buf, TAILQ_FIRST(&env->from)->mailbox, buflen);
291  else
292  *buf = '\0';
293 }
#define TAILQ_FIRST(head)
Definition: queue.h:716
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
bool check_for_mailing_list_addr(struct AddressList *al, char *buf, int buflen)
Check an address list for a mailing list.
Definition: maillist.c:103
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:716
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:547
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_EMPTY(head)
Definition: queue.h:714
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ user_in_addr()

static bool user_in_addr ( struct AddressList *  al)
static

Do any of the addresses refer to the user?

Parameters
alAddressList
Return values
trueIf any of the addresses match one of the user's addresses

Definition at line 300 of file hdrline.c.

301 {
302  struct Address *a = NULL;
303  TAILQ_FOREACH(a, al, entries)
304  if (mutt_addr_is_user(a))
305  return true;
306  return false;
307 }
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:718
An email address.
Definition: address.h:34
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:547
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ user_is_recipient()

static int user_is_recipient ( struct Email e)
static

Is the user a recipient of the message.

Parameters
eEmail to test
Return values
0User is not in list
1User is unique recipient
2User is in the TO list
3User is in the CC list
4User is originator
5Sent to a subscribed mailinglist
6User is in the Reply-To list

Definition at line 320 of file hdrline.c.

321 {
322  if (!e || !e->env)
323  return 0;
324 
325  struct Envelope *env = e->env;
326 
327  if (!e->recip_valid)
328  {
329  e->recip_valid = true;
330 
331  if (mutt_addr_is_user(TAILQ_FIRST(&env->from)))
332  e->recipient = 4;
333  else if (user_in_addr(&env->to))
334  {
335  if (TAILQ_NEXT(TAILQ_FIRST(&env->to), entries) || !TAILQ_EMPTY(&env->cc))
336  e->recipient = 2; /* non-unique recipient */
337  else
338  e->recipient = 1; /* unique recipient */
339  }
340  else if (user_in_addr(&env->cc))
341  e->recipient = 3;
342  else if (check_for_mailing_list(&env->to, NULL, NULL, 0))
343  e->recipient = 5;
344  else if (check_for_mailing_list(&env->cc, NULL, NULL, 0))
345  e->recipient = 5;
346  else if (user_in_addr(&env->reply_to))
347  e->recipient = 6;
348  else
349  e->recipient = 0;
350  }
351 
352  return e->recipient;
353 }
#define TAILQ_FIRST(head)
Definition: queue.h:716
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:62
static bool user_in_addr(struct AddressList *al)
Do any of the addresses refer to the user?
Definition: hdrline.c:300
short recipient
User_is_recipient()&#39;s return value, cached.
Definition: email.h:78
bool check_for_mailing_list(struct AddressList *al, const char *pfx, char *buf, int buflen)
Search list of addresses for a mailing list.
Definition: maillist.c:79
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct Envelope * env
Envelope information.
Definition: email.h:90
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:547
bool recip_valid
Is_recipient is valid.
Definition: email.h:58
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
#define TAILQ_NEXT(elm, field)
Definition: queue.h:825
#define TAILQ_EMPTY(head)
Definition: queue.h:714
The header of an Email.
Definition: envelope.h:54
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ apply_subject_mods()

static char* apply_subject_mods ( struct Envelope env)
static

Apply regex modifications to the subject.

Parameters
envEnvelope of email
Return values
ptrModified subject
NULLNo modification made

Definition at line 361 of file hdrline.c.

362 {
363  if (!env)
364  return NULL;
365 
367  return env->subject;
368 
369  if (!env->subject || (*env->subject == '\0'))
370  {
371  env->disp_subj = NULL;
372  return NULL;
373  }
374 
376  return env->disp_subj;
377 }
struct ReplaceList SubjectRegexList
List of regexes to tidy the view of the email&#39;s subject.
Definition: globals.c:53
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:68
char * mutt_replacelist_apply(struct ReplaceList *rl, char *buf, size_t buflen, const char *str)
Apply replacements to a buffer.
Definition: regex.c:351
char * subject
Email&#39;s subject.
Definition: envelope.h:66
#define STAILQ_EMPTY(head)
Definition: queue.h:345
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ thread_is_new()

static bool thread_is_new ( struct Email e)
static

Does the email thread contain any new emails?

Parameters
eEmail
Return values
trueIf thread contains new mail

Definition at line 384 of file hdrline.c.

385 {
386  return e->collapsed && (e->num_hidden > 1) && (mutt_thread_contains_unread(e) == 1);
387 }
#define mutt_thread_contains_unread(e)
Definition: mutt_thread.h:85
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:75
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:73
+ Here is the caller graph for this function:

◆ thread_is_old()

static bool thread_is_old ( struct Email e)
static

Does the email thread contain any unread emails?

Parameters
eEmail
Return values
trueIf thread contains unread mail

Definition at line 394 of file hdrline.c.

395 {
396  return e->collapsed && (e->num_hidden > 1) && (mutt_thread_contains_unread(e) == 2);
397 }
#define mutt_thread_contains_unread(e)
Definition: mutt_thread.h:85
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:75
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:73
+ 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
%(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 455 of file hdrline.c.

459 {
460  struct HdrFormatInfo *hfi = (struct HdrFormatInfo *) data;
461  char fmt[128], tmp[1024];
462  char *p = NULL, *tags = NULL;
463  bool optional = (flags & MUTT_FORMAT_OPTIONAL);
464  int threads = ((C_Sort & SORT_MASK) == SORT_THREADS);
465  int is_index = (flags & MUTT_FORMAT_INDEX);
466  size_t colorlen;
467 
468  struct Email *e = hfi->email;
469  size_t msg_in_pager = hfi->msg_in_pager;
470  struct Mailbox *m = hfi->mailbox;
471 
472  if (!e || !e->env)
473  return src;
474 
475  const struct Address *reply_to = TAILQ_FIRST(&e->env->reply_to);
476  const struct Address *from = TAILQ_FIRST(&e->env->from);
477  const struct Address *to = TAILQ_FIRST(&e->env->to);
478  const struct Address *cc = TAILQ_FIRST(&e->env->cc);
479 
480  buf[0] = '\0';
481  switch (op)
482  {
483  case 'A':
484  case 'I':
485  if (op == 'A')
486  {
487  if (reply_to && reply_to->mailbox)
488  {
489  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
490  mutt_format_s(buf + colorlen, buflen - colorlen, prec,
491  mutt_addr_for_display(reply_to));
492  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
493  break;
494  }
495  }
496  else
497  {
498  if (mutt_mb_get_initials(mutt_get_name(from), tmp, sizeof(tmp)))
499  {
500  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
501  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
502  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
503  break;
504  }
505  }
506  /* fallthrough */
507 
508  case 'a':
509  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
510  if (from && from->mailbox)
511  {
512  mutt_format_s(buf + colorlen, buflen - colorlen, prec, mutt_addr_for_display(from));
513  }
514  else
515  mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
516  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
517  break;
518 
519  case 'B':
520  case 'K':
521  if (!first_mailing_list(buf, buflen, &e->env->to) &&
522  !first_mailing_list(buf, buflen, &e->env->cc))
523  {
524  buf[0] = '\0';
525  }
526  if (buf[0] != '\0')
527  {
528  mutt_str_copy(tmp, buf, sizeof(tmp));
529  mutt_format_s(buf, buflen, prec, tmp);
530  break;
531  }
532  if (op == 'K')
533  {
534  if (optional)
535  optional = false;
536  /* break if 'K' returns nothing */
537  break;
538  }
539  /* if 'B' returns nothing */
540  /* fallthrough */
541 
542  case 'b':
543  if (m)
544  {
545  p = strrchr(mailbox_path(m), '/');
546 #ifdef USE_NOTMUCH
547  if (m->type == MUTT_NOTMUCH)
548  {
549  char *rel_path = nm_email_get_folder_rel_db(m, e);
550  if (rel_path)
551  p = rel_path;
552  }
553 #endif
554 
555  if (p)
556  mutt_str_copy(buf, p + 1, buflen);
557  else
558  mutt_str_copy(buf, mailbox_path(m), buflen);
559  }
560  else
561  mutt_str_copy(buf, "(null)", buflen);
562  mutt_str_copy(tmp, buf, sizeof(tmp));
563  mutt_format_s(buf, buflen, prec, tmp);
564  break;
565 
566  case 'c':
567  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
568  if (src[0] == 'r')
569  {
570  mutt_str_pretty_size(tmp, sizeof(tmp), email_size(e));
571  src++;
572  }
573  else
574  {
575  mutt_str_pretty_size(tmp, sizeof(tmp), e->body->length);
576  }
577  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
578  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
579  break;
580 
581  case 'C':
582  colorlen = add_index_color(fmt, sizeof(fmt), flags, MT_COLOR_INDEX_NUMBER);
583  snprintf(fmt + colorlen, sizeof(fmt) - colorlen, "%%%sd", prec);
584  add_index_color(fmt + colorlen, sizeof(fmt) - colorlen, flags, MT_COLOR_INDEX);
585  snprintf(buf, buflen, fmt, e->msgno + 1);
586  break;
587 
588  case 'd':
589  case 'D':
590  case '{':
591  case '[':
592  case '(':
593  case '<':
594  /* preprocess $date_format to handle %Z */
595  {
596  const char *cp = NULL;
597  time_t now;
598  int j = 0;
599 
600  if (optional && ((op == '[') || (op == '(')))
601  {
602  now = mutt_date_epoch();
603  struct tm tm = mutt_date_localtime(now);
604  now -= (op == '(') ? e->received : e->date_sent;
605 
606  char *is = (char *) prec;
607  bool invert = false;
608  if (*is == '>')
609  {
610  invert = true;
611  is++;
612  }
613 
614  while (*is && (*is != '?'))
615  {
616  int t = strtol(is, &is, 10);
617  /* semi-broken (assuming 30 days in all months) */
618  switch (*(is++))
619  {
620  case 'y':
621  if (t > 1)
622  {
623  t--;
624  t *= (60 * 60 * 24 * 365);
625  }
626  t += ((tm.tm_mon * 60 * 60 * 24 * 30) + (tm.tm_mday * 60 * 60 * 24) +
627  (tm.tm_hour * 60 * 60) + (tm.tm_min * 60) + tm.tm_sec);
628  break;
629 
630  case 'm':
631  if (t > 1)
632  {
633  t--;
634  t *= (60 * 60 * 24 * 30);
635  }
636  t += ((tm.tm_mday * 60 * 60 * 24) + (tm.tm_hour * 60 * 60) +
637  (tm.tm_min * 60) + tm.tm_sec);
638  break;
639 
640  case 'w':
641  if (t > 1)
642  {
643  t--;
644  t *= (60 * 60 * 24 * 7);
645  }
646  t += ((tm.tm_wday * 60 * 60 * 24) + (tm.tm_hour * 60 * 60) +
647  (tm.tm_min * 60) + tm.tm_sec);
648  break;
649 
650  case 'd':
651  if (t > 1)
652  {
653  t--;
654  t *= (60 * 60 * 24);
655  }
656  t += ((tm.tm_hour * 60 * 60) + (tm.tm_min * 60) + tm.tm_sec);
657  break;
658 
659  case 'H':
660  if (t > 1)
661  {
662  t--;
663  t *= (60 * 60);
664  }
665  t += ((tm.tm_min * 60) + tm.tm_sec);
666  break;
667 
668  case 'M':
669  if (t > 1)
670  {
671  t--;
672  t *= (60);
673  }
674  t += (tm.tm_sec);
675  break;
676 
677  default:
678  break;
679  }
680  j += t;
681  }
682 
683  if (j < 0)
684  j *= -1;
685 
686  if (((now > j) || (now < (-1 * j))) ^ invert)
687  optional = false;
688  break;
689  }
690 
691  p = buf;
692 
693  cp = ((op == 'd') || (op == 'D')) ? (NONULL(C_DateFormat)) : src;
694  bool do_locales;
695  if (*cp == '!')
696  {
697  do_locales = false;
698  cp++;
699  }
700  else
701  do_locales = true;
702 
703  size_t len = buflen - 1;
704  while ((len > 0) &&
705  ((((op == 'd') || (op == 'D')) && *cp) ||
706  ((op == '{') && (*cp != '}')) || ((op == '[') && (*cp != ']')) ||
707  ((op == '(') && (*cp != ')')) || ((op == '<') && (*cp != '>'))))
708  {
709  if (*cp == '%')
710  {
711  cp++;
712  if (((*cp == 'Z') || (*cp == 'z')) && ((op == 'd') || (op == '{')))
713  {
714  if (len >= 5)
715  {
716  sprintf(p, "%c%02u%02u", e->zoccident ? '-' : '+', e->zhours, e->zminutes);
717  p += 5;
718  len -= 5;
719  }
720  else
721  break; /* not enough space left */
722  }
723  else
724  {
725  if (len >= 2)
726  {
727  *p++ = '%';
728  *p++ = *cp;
729  len -= 2;
730  }
731  else
732  break; /* not enough space */
733  }
734  cp++;
735  }
736  else
737  {
738  *p++ = *cp++;
739  len--;
740  }
741  }
742  *p = '\0';
743 
744  struct tm tm;
745  if ((op == '[') || (op == 'D'))
747  else if (op == '(')
748  tm = mutt_date_localtime(e->received);
749  else if (op == '<')
750  {
752  }
753  else
754  {
755  /* restore sender's time zone */
756  now = e->date_sent;
757  if (e->zoccident)
758  now -= (e->zhours * 3600 + e->zminutes * 60);
759  else
760  now += (e->zhours * 3600 + e->zminutes * 60);
761  tm = mutt_date_gmtime(now);
762  }
763 
764  if (!do_locales)
765  setlocale(LC_TIME, "C");
766  strftime(tmp, sizeof(tmp), buf, &tm);
767  if (!do_locales)
768  setlocale(LC_TIME, "");
769 
770  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_DATE);
771  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
772  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
773 
774  if ((len > 0) && (op != 'd') && (op != 'D')) /* Skip ending op */
775  src = cp + 1;
776  break;
777  }
778 
779  case 'e':
780  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
781  snprintf(buf, buflen, fmt, mutt_messages_in_thread(m, e, 1));
782  break;
783 
784  case 'E':
785  if (!optional)
786  {
787  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
788  snprintf(buf, buflen, fmt, mutt_messages_in_thread(m, e, 0));
789  }
790  else if (mutt_messages_in_thread(m, e, 0) <= 1)
791  optional = false;
792  break;
793 
794  case 'f':
795  tmp[0] = '\0';
796  mutt_addrlist_write(&e->env->from, tmp, sizeof(tmp), true);
797  mutt_format_s(buf, buflen, prec, tmp);
798  break;
799 
800  case 'F':
801  if (!optional)
802  {
803  const bool is_plain = (src[0] == 'p');
804  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
805  make_from(e->env, tmp, sizeof(tmp), false,
806  (is_plain ? MUTT_FORMAT_PLAIN : MUTT_FORMAT_NO_FLAGS));
807  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
808  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
809 
810  if (is_plain)
811  src++;
812  }
813  else if (mutt_addr_is_user(from))
814  {
815  optional = false;
816  }
817  break;
818 
819  case 'g':
820  tags = driver_tags_get_transformed(&e->tags);
821  if (!optional)
822  {
823  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
824  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
825  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
826  }
827  else if (!tags)
828  optional = false;
829  FREE(&tags);
830  break;
831 
832  case 'G':
833  {
834  char format[3];
835  char *tag = NULL;
836 
837  if (!optional)
838  {
839  format[0] = op;
840  format[1] = *src;
841  format[2] = '\0';
842 
843  tag = mutt_hash_find(TagFormats, format);
844  if (tag)
845  {
846  tags = driver_tags_get_transformed_for(&e->tags, tag);
847  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAG);
848  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(tags));
849  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
850  FREE(&tags);
851  }
852  src++;
853  }
854  else
855  {
856  format[0] = op;
857  format[1] = *prec;
858  format[2] = '\0';
859 
860  tag = mutt_hash_find(TagFormats, format);
861  if (tag)
862  {
863  tags = driver_tags_get_transformed_for(&e->tags, tag);
864  if (!tags)
865  optional = false;
866  FREE(&tags);
867  }
868  }
869  break;
870  }
871 
872  case 'H':
873  /* (Hormel) spam score */
874  if (optional)
875  optional = !mutt_buffer_is_empty(&e->env->spam);
876 
877  mutt_format_s(buf, buflen, prec, mutt_b2s(&e->env->spam));
878  break;
879 
880  case 'i':
881  mutt_format_s(buf, buflen, prec, e->env->message_id ? e->env->message_id : "<no.id>");
882  break;
883 
884  case 'J':
885  {
886  bool have_tags = true;
887  tags = driver_tags_get_transformed(&e->tags);
888  if (tags)
889  {
890  if (flags & MUTT_FORMAT_TREE)
891  {
892  char *parent_tags = NULL;
893  if (e->thread->prev && e->thread->prev->message)
894  {
895  parent_tags = driver_tags_get_transformed(&e->thread->prev->message->tags);
896  }
897  if (!parent_tags && e->thread->parent && e->thread->parent->message)
898  {
899  parent_tags =
901  }
902  if (parent_tags && mutt_istr_equal(tags, parent_tags))
903  have_tags = false;
904  FREE(&parent_tags);
905  }
906  }
907  else
908  have_tags = false;
909 
910  if (optional)
911  optional = have_tags;
912 
913  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_TAGS);
914  if (have_tags)
915  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tags);
916  else
917  mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
918  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
919  FREE(&tags);
920  break;
921  }
922 
923  case 'l':
924  if (!optional)
925  {
926  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
927  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SIZE);
928  snprintf(buf + colorlen, buflen - colorlen, fmt, (int) e->lines);
929  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
930  }
931  else if (e->lines <= 0)
932  optional = false;
933  break;
934 
935  case 'L':
936  if (!optional)
937  {
938  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
939  make_from(e->env, tmp, sizeof(tmp), true, flags);
940  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
941  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
942  }
943  else if (!check_for_mailing_list(&e->env->to, NULL, NULL, 0) &&
944  !check_for_mailing_list(&e->env->cc, NULL, NULL, 0))
945  {
946  optional = false;
947  }
948  break;
949 
950  case 'm':
951  if (m)
952  {
953  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
954  snprintf(buf, buflen, fmt, m->msg_count);
955  }
956  else
957  mutt_str_copy(buf, "(null)", buflen);
958  break;
959 
960  case 'n':
961  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_AUTHOR);
962  mutt_format_s(buf + colorlen, buflen - colorlen, prec, mutt_get_name(from));
963  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
964  break;
965 
966  case 'M':
967  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
968  if (!optional)
969  {
970  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_COLLAPSED);
971  if (threads && is_index && e->collapsed && (e->num_hidden > 1))
972  {
973  snprintf(buf + colorlen, buflen - colorlen, fmt, e->num_hidden);
974  add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
975  }
976  else if (is_index && threads)
977  {
978  mutt_format_s(buf + colorlen, buflen - colorlen, prec, " ");
979  add_index_color(buf, buflen - colorlen, flags, MT_COLOR_INDEX);
980  }
981  else
982  *buf = '\0';
983  }
984  else
985  {
986  if (!(threads && is_index && e->collapsed && (e->num_hidden > 1)))
987  optional = false;
988  }
989  break;
990 
991  case 'N':
992  if (!optional)
993  {
994  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
995  snprintf(buf, buflen, fmt, e->score);
996  }
997  else
998  {
999  if (e->score == 0)
1000  optional = false;
1001  }
1002  break;
1003 
1004  case 'O':
1005  if (!optional)
1006  {
1007  make_from_addr(e->env, tmp, sizeof(tmp), true);
1008  if (!C_SaveAddress && (p = strpbrk(tmp, "%@")))
1009  *p = '\0';
1010  mutt_format_s(buf, buflen, prec, tmp);
1011  }
1012  else if (!check_for_mailing_list_addr(&e->env->to, NULL, 0) &&
1013  !check_for_mailing_list_addr(&e->env->cc, NULL, 0))
1014  {
1015  optional = false;
1016  }
1017  break;
1018 
1019  case 'P':
1020  mutt_str_copy(buf, hfi->pager_progress, buflen);
1021  break;
1022 
1023 #ifdef USE_NNTP
1024  case 'q':
1025  mutt_format_s(buf, buflen, prec, e->env->newsgroups ? e->env->newsgroups : "");
1026  break;
1027 #endif
1028 
1029  case 'r':
1030  tmp[0] = '\0';
1031  mutt_addrlist_write(&e->env->to, tmp, sizeof(tmp), true);
1032  if (optional && (tmp[0] == '\0'))
1033  optional = false;
1034  mutt_format_s(buf, buflen, prec, tmp);
1035  break;
1036 
1037  case 'R':
1038  tmp[0] = '\0';
1039  mutt_addrlist_write(&e->env->cc, tmp, sizeof(tmp), true);
1040  if (optional && (tmp[0] == '\0'))
1041  optional = false;
1042  mutt_format_s(buf, buflen, prec, tmp);
1043  break;
1044 
1045  case 's':
1046  {
1047  char *subj = NULL;
1048  if (e->env->disp_subj)
1049  subj = e->env->disp_subj;
1050  else if (!STAILQ_EMPTY(&SubjectRegexList))
1051  subj = apply_subject_mods(e->env);
1052  else
1053  subj = e->env->subject;
1054  if (flags & MUTT_FORMAT_TREE && !e->collapsed)
1055  {
1056  if (flags & MUTT_FORMAT_FORCESUBJ)
1057  {
1058  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
1059  mutt_format_s(buf + colorlen, buflen - colorlen, "", NONULL(subj));
1060  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1061  snprintf(tmp, sizeof(tmp), "%s%s", e->tree, buf);
1062  mutt_format_s_tree(buf, buflen, prec, tmp);
1063  }
1064  else
1065  mutt_format_s_tree(buf, buflen, prec, e->tree);
1066  }
1067  else
1068  {
1069  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_SUBJECT);
1070  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(subj));
1071  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1072  }
1073  break;
1074  }
1075 
1076  case 'S':
1077  {
1078  const char *wch = NULL;
1079  if (e->deleted)
1081  else if (e->attach_del)
1083  else if (e->tagged)
1085  else if (e->flagged)
1087  else if (e->replied)
1089  else if (e->read && (msg_in_pager != e->msgno))
1091  else if (e->old)
1093  else
1095 
1096  snprintf(tmp, sizeof(tmp), "%s", wch);
1097  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
1098  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
1099  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1100  break;
1101  }
1102 
1103  case 't':
1104  tmp[0] = '\0';
1105  if (!check_for_mailing_list(&e->env->to, "To ", tmp, sizeof(tmp)) &&
1106  !check_for_mailing_list(&e->env->cc, "Cc ", tmp, sizeof(tmp)))
1107  {
1108  if (to)
1109  snprintf(tmp, sizeof(tmp), "To %s", mutt_get_name(to));
1110  else if (cc)
1111  snprintf(tmp, sizeof(tmp), "Cc %s", mutt_get_name(cc));
1112  }
1113  mutt_format_s(buf, buflen, prec, tmp);
1114  break;
1115 
1116  case 'T':
1117  {
1118  int i;
1119  snprintf(fmt, sizeof(fmt), "%%%ss", prec);
1120  snprintf(buf, buflen, fmt,
1121  (C_ToChars && ((i = user_is_recipient(e))) < C_ToChars->len) ?
1122  C_ToChars->chars[i] :
1123  " ");
1124  break;
1125  }
1126 
1127  case 'u':
1128  if (from && from->mailbox)
1129  {
1130  mutt_str_copy(tmp, mutt_addr_for_display(from), sizeof(tmp));
1131  p = strpbrk(tmp, "%@");
1132  if (p)
1133  *p = '\0';
1134  }
1135  else
1136  tmp[0] = '\0';
1137  mutt_format_s(buf, buflen, prec, tmp);
1138  break;
1139 
1140  case 'v':
1141  if (mutt_addr_is_user(from))
1142  {
1143  if (to)
1144  mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(to));
1145  else if (cc)
1146  mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(cc));
1147  else
1148  *tmp = '\0';
1149  }
1150  else
1151  mutt_format_s(tmp, sizeof(tmp), prec, mutt_get_name(from));
1152  p = strpbrk(tmp, " %@");
1153  if (p)
1154  *p = '\0';
1155  mutt_format_s(buf, buflen, prec, tmp);
1156  break;
1157 
1158  case 'W':
1159  if (!optional)
1160  {
1161  mutt_format_s(buf, buflen, prec, e->env->organization ? e->env->organization : "");
1162  }
1163  else if (!e->env->organization)
1164  optional = false;
1165  break;
1166 
1167 #ifdef USE_NNTP
1168  case 'x':
1169  if (!optional)
1170  {
1171  mutt_format_s(buf, buflen, prec, e->env->x_comment_to ? e->env->x_comment_to : "");
1172  }
1173  else if (!e->env->x_comment_to)
1174  optional = false;
1175  break;
1176 #endif
1177 
1178  case 'X':
1179  {
1180  int count = mutt_count_body_parts(m, e);
1181 
1182  /* The recursion allows messages without depth to return 0. */
1183  if (optional)
1184  optional = (count != 0);
1185 
1186  snprintf(fmt, sizeof(fmt), "%%%sd", prec);
1187  snprintf(buf, buflen, fmt, count);
1188  break;
1189  }
1190 
1191  case 'y':
1192  if (optional)
1193  optional = (e->env->x_label != NULL);
1194 
1195  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
1196  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(e->env->x_label));
1197  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1198  break;
1199 
1200  case 'Y':
1201  {
1202  bool label = true;
1203  if (e->env->x_label)
1204  {
1205  struct Email *e_tmp = NULL;
1206  if (flags & MUTT_FORMAT_TREE && (e->thread->prev && e->thread->prev->message &&
1207  e->thread->prev->message->env->x_label))
1208  {
1209  e_tmp = e->thread->prev->message;
1210  }
1211  else if (flags & MUTT_FORMAT_TREE &&
1212  (e->thread->parent && e->thread->parent->message &&
1213  e->thread->parent->message->env->x_label))
1214  {
1215  e_tmp = e->thread->parent->message;
1216  }
1217  if (e_tmp && mutt_istr_equal(e->env->x_label, e_tmp->env->x_label))
1218  label = false;
1219  }
1220  else
1221  label = false;
1222 
1223  if (optional)
1224  optional = label;
1225 
1226  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_LABEL);
1227  if (label)
1228  mutt_format_s(buf + colorlen, buflen - colorlen, prec, NONULL(e->env->x_label));
1229  else
1230  mutt_format_s(buf + colorlen, buflen - colorlen, prec, "");
1231  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1232  break;
1233  }
1234 
1235  case 'z':
1236  if (src[0] == 's') /* status: deleted/new/old/replied */
1237  {
1238  const char *ch = NULL;
1239  if (e->deleted)
1241  else if (e->attach_del)
1243  else if (threads && thread_is_new(e))
1245  else if (threads && thread_is_old(e))
1247  else if (e->read && (msg_in_pager != e->msgno))
1248  {
1249  if (e->replied)
1251  else
1253  }
1254  else
1255  {
1256  if (e->old)
1258  else
1260  }
1261 
1262  snprintf(tmp, sizeof(tmp), "%s", ch);
1263  src++;
1264  }
1265  else if (src[0] == 'c') /* crypto */
1266  {
1267  const char *ch = "";
1268  if ((WithCrypto != 0) && (e->security & SEC_GOODSIGN))
1270  else if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
1272  else if ((WithCrypto != 0) && (e->security & SEC_SIGN))
1274  else if (((WithCrypto & APPLICATION_PGP) != 0) && ((e->security & PGP_KEY) == PGP_KEY))
1275  {
1277  }
1278  else
1280 
1281  snprintf(tmp, sizeof(tmp), "%s", ch);
1282  src++;
1283  }
1284  else if (src[0] == 't') /* tagged, flagged, recipient */
1285  {
1286  const char *ch = "";
1287  if (e->tagged)
1289  else if (e->flagged)
1291  else
1293 
1294  snprintf(tmp, sizeof(tmp), "%s", ch);
1295  src++;
1296  }
1297  else /* fallthrough */
1298  break;
1299 
1300  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
1301  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
1302  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1303  break;
1304 
1305  case 'Z':
1306  {
1307  /* New/Old for threads; replied; New/Old for messages */
1308  const char *first = NULL;
1309  if (threads && thread_is_new(e))
1311  else if (threads && thread_is_old(e))
1313  else if (e->read && (msg_in_pager != e->msgno))
1314  {
1315  if (e->replied)
1317  else
1319  }
1320  else
1321  {
1322  if (e->old)
1324  else
1326  }
1327 
1328  /* Marked for deletion; deleted attachments; crypto */
1329  const char *second = "";
1330  if (e->deleted)
1332  else if (e->attach_del)
1334  else if ((WithCrypto != 0) && (e->security & SEC_GOODSIGN))
1336  else if ((WithCrypto != 0) && (e->security & SEC_ENCRYPT))
1338  else if ((WithCrypto != 0) && (e->security & SEC_SIGN))
1340  else if (((WithCrypto & APPLICATION_PGP) != 0) && (e->security & PGP_KEY))
1342  else
1344 
1345  /* Tagged, flagged and recipient flag */
1346  const char *third = "";
1347  if (e->tagged)
1349  else if (e->flagged)
1351  else
1353 
1354  snprintf(tmp, sizeof(tmp), "%s%s%s", first, second, third);
1355  }
1356 
1357  colorlen = add_index_color(buf, buflen, flags, MT_COLOR_INDEX_FLAGS);
1358  mutt_format_s(buf + colorlen, buflen - colorlen, prec, tmp);
1359  add_index_color(buf + colorlen, buflen - colorlen, flags, MT_COLOR_INDEX);
1360  break;
1361 
1362  case '@':
1363  {
1364  const char *end = src;
1365  static unsigned char recurse = 0;
1366 
1367  while ((*end != '\0') && (*end != '@'))
1368  end++;
1369  if ((*end == '@') && (recurse < 20))
1370  {
1371  recurse++;
1372  mutt_strn_copy(tmp, src, end - src, sizeof(tmp));
1373  mutt_expando_format(tmp, sizeof(tmp), col, cols,
1374  NONULL(mutt_idxfmt_hook(tmp, m, e)),
1375  index_format_str, data, flags);
1376  mutt_format_s_x(buf, buflen, prec, tmp, true);
1377  recurse--;
1378 
1379  src = end + 1;
1380  break;
1381  }
1382  }
1383  /* fallthrough */
1384 
1385  default:
1386  snprintf(buf, buflen, "%%%s%c", prec, op);
1387  break;
1388  }
1389 
1390  if (optional)
1391  {
1392  mutt_expando_format(buf, buflen, col, cols, if_str, index_format_str,
1393  (intptr_t) hfi, flags);
1394  }
1395  else if (flags & MUTT_FORMAT_OPTIONAL)
1396  {
1397  mutt_expando_format(buf, buflen, col, cols, else_str, index_format_str,
1398  (intptr_t) hfi, flags);
1399  }
1400 
1401  return src;
1402 }
void * mutt_hash_find(const struct HashTable *table, const char *strkey)
Find the HashElem data in a Hash Table element using a key.
Definition: hash.c:354
time_t mutt_date_epoch(void)
Return the number of seconds since the Unix epoch.
Definition: date.c:416
Character denoting a tagged email.
Definition: hdrline.c:74
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:203
Index: index number.
Definition: color.h:109
Character denoting a important (flagged) email.
Definition: hdrline.c:75
int lines
How many lines in the body of this message?
Definition: email.h:85
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
#define NONULL(x)
Definition: string2.h:37
int msg_count
Total number of messages.
Definition: mailbox.h:91
#define WithCrypto
Definition: lib.h:123
The envelope/body of an email.
Definition: email.h:37
Index: tags field (g, J)
Definition: color.h:111
#define TAILQ_FIRST(head)
Definition: queue.h:716
char ** chars
The array of multibyte character strings.
Definition: mbtable.h:39
struct Body * body
List of MIME parts.
Definition: email.h:91
struct ReplaceList SubjectRegexList
List of regexes to tidy the view of the email&#39;s subject.
Definition: globals.c:53
struct AddressList reply_to
Email&#39;s &#39;reply-to&#39;.
Definition: envelope.h:62
struct tm mutt_date_localtime(time_t t)
Converts calendar time to a broken-down time structure expressed in user timezone.
Definition: date.c:643
#define MUTT_FORMAT_FORCESUBJ
Print the subject even if unchanged.
Definition: format_flags.h:31
static bool thread_is_new(struct Email *e)
Does the email thread contain any new emails?
Definition: hdrline.c:384
struct MuttThread * thread
Thread of Emails.
Definition: email.h:95
char * disp_subj
Display subject (modified copy of subject)
Definition: envelope.h:68
Character denoting a thread containing at least one new email.
Definition: hdrline.c:82
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:85
bool attach_del
Has an attachment marked for deletion.
Definition: email.h:49
Character denoting a message contains a PGP key.
Definition: hdrline.c:95
An email address.
Definition: address.h:34
#define MUTT_DATE_NOW
Constant representing the &#39;current time&#39;, see: mutt_date_gmtime(), mutt_date_localtime() ...
Definition: date.h:39
struct MuttThread * parent
Parent of this Thread.
Definition: thread.h:45
char * mailbox
Mailbox and host address.
Definition: address.h:37
Character denoting a read email, $index_format S expando.
Definition: hdrline.c:83
struct tm mutt_date_gmtime(time_t t)
Converts calendar time to a broken-down time structure expressed in UTC timezone. ...
Definition: date.c:661
static bool thread_is_old(struct Email *e)
Does the email thread contain any unread emails?
Definition: hdrline.c:394
bool zoccident
True, if west of UTC, False if east.
Definition: email.h:65
Index: number of messages in collapsed thread.
Definition: color.h:106
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
struct MbTable * C_ToChars
Config: Indicator characters for the &#39;To&#39; field in the index.
Definition: hdrline.c:67
static char * apply_subject_mods(struct Envelope *env)
Apply regex modifications to the subject.
Definition: hdrline.c:361
static void make_from(struct Envelope *env, char *buf, size_t buflen, bool do_lists, MuttFormatFlags flags)
Generate a From: field (with optional prefix)
Definition: hdrline.c:214
bool check_for_mailing_list(struct AddressList *al, const char *pfx, char *buf, int buflen)
Search list of addresses for a mailing list.
Definition: maillist.c:79
Index: author field (takes a pattern)
Definition: color.h:101
bool tagged
Email is tagged.
Definition: email.h:44
bool read
Email is read.
Definition: email.h:51
const char * mutt_addr_for_display(const struct Address *a)
Convert an Address for display purposes.
Definition: address.c:986
char * message_id
Message ID.
Definition: envelope.h:69
struct MuttThread * prev
Previous sibling Thread.
Definition: thread.h:48
#define MUTT_FORMAT_TREE
Draw the thread tree.
Definition: format_flags.h:32
bool old
Email is seen, but unread.
Definition: email.h:50
Data passed to index_format_str()
Definition: hdrline.h:44
struct AddressList from
Email&#39;s &#39;From&#39; list.
Definition: envelope.h:57
struct Envelope * env
Envelope information.
Definition: email.h:90
Index: tag field (g, takes a pattern)
Definition: color.h:104
Character denoting a deleted attachment.
Definition: hdrline.c:77
struct Mailbox * mailbox
Definition: hdrline.h:46
struct AddressList cc
Email&#39;s &#39;Cc&#39; list.
Definition: envelope.h:59
Character denoting an email that has been read.
Definition: hdrline.c:79
static int user_is_recipient(struct Email *e)
Is the user a recipient of the message.
Definition: hdrline.c:320
Character denoting a thread of emails that has been read.
Definition: hdrline.c:81
WHERE short C_Sort
Config: Sort method for the index.
Definition: sort.h:60
struct TagList tags
For drivers that support server tagging.
Definition: email.h:109
char * mutt_strn_copy(char *dest, const char *src, size_t len, size_t dsize)
Copy a sub-string into a buffer.
Definition: string.c:528
int score
Message score.
Definition: email.h:89
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:883
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:82
#define mutt_b2s(buf)
Definition: buffer.h:41
Index: date field.
Definition: color.h:107
char * x_comment_to
List of &#39;X-comment-to&#39; fields.
Definition: envelope.h:78
const char * mutt_idxfmt_hook(const char *name, struct Mailbox *m, struct Email *e)
Get index-format-hook format string.
Definition: hook.c:866
Sort by email threads.
Definition: sort2.h:51
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:97
Character denoting an email that has been replied to.
Definition: hdrline.c:78
Index: size field.
Definition: color.h:110
char * driver_tags_get_transformed_for(struct TagList *head, const char *name)
Get transformed tag for a tag name from a header.
Definition: tags.c:169
WHERE bool C_SaveAddress
Config: Use sender&#39;s full address as a default save folder.
Definition: mutt_globals.h:157
LOFF_T length
length (in bytes) of attachment
Definition: body.h:45
A mailbox.
Definition: mailbox.h:81
void mutt_format_s_x(char *buf, size_t buflen, const char *prec, const char *s, bool arboreal)
Format a string like snprintf()
Definition: curs_lib.c:1207
bool check_for_mailing_list_addr(struct AddressList *al, char *buf, int buflen)
Check an address list for a mailing list.
Definition: maillist.c:103
static void make_from_addr(struct Envelope *env, char *buf, size_t buflen, bool do_lists)
Create a &#39;from&#39; address for a reply email.
Definition: hdrline.c:270
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:75
void mutt_str_pretty_size(char *buf, size_t buflen, size_t num)
Display an abbreviated size, like 3.4K.
Definition: muttlib.c:1659
Character denoting a message signed with a verified key.
Definition: hdrline.c:92
bool mutt_mb_get_initials(const char *name, char *buf, size_t buflen)
Turn a name into initials.
Definition: mbyte.c:84
static size_t add_index_color(char *buf, size_t buflen, MuttFormatFlags flags, char color)
Insert a color marker into a string.
Definition: hdrline.c:124
int msg_in_pager
Definition: hdrline.h:47
bool collapsed
Is this message part of a collapsed thread?
Definition: email.h:73
Character denoting a message is PGP-encrypted.
Definition: hdrline.c:93
int mutt_messages_in_thread(struct Mailbox *m, struct Email *e, int flag)
Count the messages in a thread.
Definition: mutt_thread.c:1479
unsigned int zhours
Hours away from UTC.
Definition: email.h:63
char * tree
Character string to print thread tree.
Definition: email.h:94
SecurityFlags security
bit 0-10: flags, bit 11,12: application, bit 13: traditional pgp See: ncrypt/lib.h pgplib...
Definition: email.h:39
struct Email * message
Email this Thread refers to.
Definition: thread.h:49
static const char * get_nth_wchar(struct MbTable *table, int index)
Extract one char from a multi-byte table.
Definition: hdrline.c:161
&#39;Notmuch&#39; (virtual) Mailbox type
Definition: mailbox.h:54
#define SEC_SIGN
Email is signed.
Definition: lib.h:86
Character denoting a read email, $index_format Z expando.
Definition: hdrline.c:84
#define MUTT_FORMAT_INDEX
This is a main index entry.
Definition: format_flags.h:36
Index: label field.
Definition: color.h:108
char * subject
Email&#39;s subject.
Definition: envelope.h:66
WHERE char * C_DateFormat
Config: strftime format string for the d expando.
Definition: mutt_globals.h:89
Index: subject field (takes a pattern)
Definition: color.h:103
void mutt_format_s(char *buf, size_t buflen, const char *prec, const char *s)
Format a simple string.
Definition: curs_lib.c:1244
#define PGP_KEY
Definition: lib.h:106
#define MUTT_FORMAT_PLAIN
Do not prepend DISP_TO, DISP_CC ...
Definition: format_flags.h:38
bool flagged
Marked important?
Definition: email.h:43
char * newsgroups
List of newsgroups.
Definition: envelope.h:75
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:716
Character denoting a deleted email.
Definition: hdrline.c:76
struct MbTable * C_FlagChars
Config: User-configurable index flags: tagged, new, etc.
Definition: hdrline.c:65
char * driver_tags_get_transformed(struct TagList *list)
Get transformed tags.
Definition: tags.c:130
bool deleted
Email is deleted.
Definition: email.h:45
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.
Definition: muttlib.c:772
bool replied
Email has been replied to.
Definition: email.h:54
Character denoting an unread email.
Definition: hdrline.c:80
Character denoting a message has no cryptography information.
Definition: hdrline.c:96
#define FREE(x)
Definition: memory.h:40
bool mutt_addr_is_user(const struct Address *addr)
Does the address belong to the user.
Definition: alias.c:547
const char * pager_progress
Definition: hdrline.h:49
char * organization
Organisation header.
Definition: envelope.h:73
Character denoting a message is signed.
Definition: hdrline.c:94
#define STAILQ_EMPTY(head)
Definition: queue.h:345
#define MUTT_FORMAT_OPTIONAL
Allow optional field processing.
Definition: format_flags.h:33
struct AddressList to
Email&#39;s &#39;To&#39; list.
Definition: envelope.h:58
char * nm_email_get_folder_rel_db(struct Mailbox *m, struct Email *e)
Get the folder for a Email from the same level as the notmuch database.
Definition: notmuch.c:1688
int mutt_count_body_parts(struct Mailbox *m, struct Email *e)
Count the MIME Body parts.
Definition: mutt_parse.c:206
bool first_mailing_list(char *buf, size_t buflen, struct AddressList *al)
Get the first mailing list in the list of addresses.
Definition: maillist.c:125
Index: default colour (takes a pattern)
Definition: color.h:100
struct MbTable * C_CryptChars
Config: User-configurable crypto flags: signed, encrypted etc.
Definition: hdrline.c:64
WHERE struct HashTable * TagFormats
Hash Table of tag-formats (tag -> format string)
Definition: mutt_globals.h:59
struct Email * email
Definition: hdrline.h:48
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
char * x_label
X-Label.
Definition: envelope.h:72
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:87
size_t mutt_addrlist_write(const struct AddressList *al, char *buf, size_t buflen, bool display)
Write an Address to a buffer.
Definition: address.c:1150
unsigned int zminutes
Minutes away from UTC.
Definition: email.h:64
size_t email_size(const struct Email *e)
compute the size of an email
Definition: email.c:117
#define SORT_MASK
Mask for the sort id.
Definition: sort2.h:80
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:83
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.
Definition: hdrline.c:455
Index: flags field (takes a pattern)
Definition: color.h:102
struct Buffer spam
Spam header.
Definition: envelope.h:80
int len
Number of characters.
Definition: mbtable.h:38
void mutt_format_s_tree(char *buf, size_t buflen, const char *prec, const char *s)
Format a simple string with tree characters.
Definition: curs_lib.c:1256
int msgno
Number displayed to the user.
Definition: email.h:87
const char * mutt_get_name(const struct Address *a)
Pick the best name to display from an address.
Definition: sort.c:157
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_string_flags()

void mutt_make_string_flags ( char *  buf,
size_t  buflen,
int  cols,
const char *  s,
struct Mailbox m,
int  inpgr,
struct Email e,
MuttFormatFlags  flags 
)

Create formatted strings using mailbox expandos.

Parameters
bufBuffer for the result
buflenBuffer length
colsNumber of screen columns (OPTIONAL)
sprintf-line format string
mMailbox
inpgrMessage shown in the pager
eEmail
flagsFlags, see MuttFormatFlags

Definition at line 1415 of file hdrline.c.

1418 {
1419  struct HdrFormatInfo hfi;
1420 
1421  hfi.email = e;
1422  hfi.mailbox = m;
1423  hfi.msg_in_pager = inpgr;
1424  hfi.pager_progress = 0;
1425 
1426  mutt_expando_format(buf, buflen, 0, cols, s, index_format_str, (intptr_t) &hfi, flags);
1427 }
Data passed to index_format_str()
Definition: hdrline.h:44
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.
Definition: muttlib.c:772
struct Email * email
Definition: hdrline.h:48
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.
Definition: hdrline.c:455
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_make_string_info()

void mutt_make_string_info ( char *  buf,
size_t  buflen,
int  cols,
const char *  s,
struct HdrFormatInfo hfi,
MuttFormatFlags  flags 
)

Create pager status bar string.

Parameters
bufBuffer for the result
buflenBuffer length
colsNumber of screen columns
sprintf-line format string
hfiMailbox data to pass to the formatter
flagsFlags, see MuttFormatFlags

Definition at line 1438 of file hdrline.c.

1440 {
1441  mutt_expando_format(buf, buflen, 0, cols, s, index_format_str, (intptr_t) hfi, flags);
1442 }
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.
Definition: muttlib.c:772
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.
Definition: hdrline.c:455
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ C_CryptChars

struct MbTable* C_CryptChars

Config: User-configurable crypto flags: signed, encrypted etc.

Definition at line 64 of file hdrline.c.

◆ C_FlagChars

struct MbTable* C_FlagChars

Config: User-configurable index flags: tagged, new, etc.

Definition at line 65 of file hdrline.c.

◆ C_FromChars

struct MbTable* C_FromChars

Config: User-configurable index flags: to address, cc address, etc.

Definition at line 66 of file hdrline.c.

◆ C_ToChars

struct MbTable* C_ToChars

Config: Indicator characters for the 'To' field in the index.

Definition at line 67 of file hdrline.c.