Functions to parse commands in a config file. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <unistd.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 "mutt.h"
#include "commands.h"
#include "attach/lib.h"
#include "color/lib.h"
#include "imap/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "pager/lib.h"
#include "parse/lib.h"
#include "store/lib.h"
#include "alternates.h"
#include "globals.h"
#include "muttlib.h"
#include "mx.h"
#include "score.h"
#include "version.h"
#include "monitor.h"
#include <libintl.h>

Include dependency graph for commands.c:

Go to the source code of this file.

Macros
#define	MAX_ERRS 128

Enumerations
enum	TriBool { TB_UNSET = -1 , TB_FALSE , TB_TRUE }
	Tri-state boolean. More...

enum	GroupState { GS_NONE , GS_RX , GS_ADDR }
	Type of email address group. More...

Functions
static bool	is_function (const char *name)
	Is the argument a neomutt function?

int	parse_grouplist (struct GroupList gl, struct Buffer buf, struct Buffer s, struct Buffer err)
	Parse a group context.

enum CommandResult	parse_rc_line_cwd (const char line, char cwd, struct Buffer *err)
	Parse and run a muttrc line in a relative directory.

char *	mutt_get_sourced_cwd (void)
	Get the current file path that is being parsed.

int	source_rc (const char rcfile_path, struct Buffer err)
	Read an initialization file.

static enum CommandResult	parse_cd (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'cd' command - Implements Command::parse() -.

static enum CommandResult	parse_echo (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'echo' command - Implements Command::parse() -.

static enum CommandResult	parse_finish (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'finish' command - Implements Command::parse() -.

static enum CommandResult	parse_group (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'group' and 'ungroup' commands - Implements Command::parse() -.

static enum CommandResult	parse_ifdef (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'ifdef' and 'ifndef' commands - Implements Command::parse() -.

static enum CommandResult	parse_ignore (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'ignore' command - Implements Command::parse() -.

static enum CommandResult	parse_lists (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'lists' command - Implements Command::parse() -.

static enum CommandResult	mailbox_add (const char folder, const char mailbox, const char label, enum TriBool poll, enum TriBool notify, struct Buffer err)
	Add a new Mailbox.

bool	mailbox_add_simple (const char mailbox, struct Buffer err)
	Add a new Mailbox.

enum CommandResult	parse_mailboxes (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'mailboxes' command - Implements Command::parse() -.

enum CommandResult	parse_my_hdr (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'my_hdr' command - Implements Command::parse() -.

enum CommandResult	set_dump (ConfigDumpFlags flags, struct Buffer *err)
	Dump list of config variables into a file/pager.

static int	envlist_sort (const void a, const void b, void *sdata)
	Compare two environment strings - Implements sort_t -.

static enum CommandResult	parse_setenv (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'setenv' and 'unsetenv' commands - Implements Command::parse() -.

static enum CommandResult	parse_source (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'source' command - Implements Command::parse() -.

static enum CommandResult	parse_nospam (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'nospam' command - Implements Command::parse() -.

static enum CommandResult	parse_spam (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'spam' command - Implements Command::parse() -.

static enum CommandResult	parse_stailq (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse a list command - Implements Command::parse() -.

static enum CommandResult	parse_subscribe (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'subscribe' command - Implements Command::parse() -.

enum CommandResult	parse_subscribe_to (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'subscribe-to' command - Implements Command::parse() -.

static enum CommandResult	parse_tag_formats (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'tag-formats' command - Implements Command::parse() -.

static enum CommandResult	parse_tag_transforms (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'tag-transforms' command - Implements Command::parse() -.

static enum CommandResult	parse_unignore (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'unignore' command - Implements Command::parse() -.

static enum CommandResult	parse_unlists (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'unlists' command - Implements Command::parse() -.

static void	do_unmailboxes (struct Mailbox *m)
	Remove a Mailbox from the Sidebar/notifications.

static void	do_unmailboxes_star (void)
	Remove all Mailboxes from the Sidebar/notifications.

enum CommandResult	parse_unmailboxes (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'unmailboxes' command - Implements Command::parse() -.

static enum CommandResult	parse_unmy_hdr (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'unmy_hdr' command - Implements Command::parse() -.

static enum CommandResult	parse_unstailq (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse an unlist command - Implements Command::parse() -.

static enum CommandResult	parse_unsubscribe (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'unsubscribe' command - Implements Command::parse() -.

enum CommandResult	parse_unsubscribe_from (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'unsubscribe-from' command - Implements Command::parse() -.

static enum CommandResult	parse_version (struct Buffer buf, struct Buffer s, intptr_t data, struct Buffer *err)
	Parse the 'version' command - Implements Command::parse() -.

void	source_stack_cleanup (void)
	Free memory from the stack used for the source command.

void	commands_init (void)
	Initialize commands array and register default commands.

Variables
static struct ListHead	MuttrcStack = STAILQ_HEAD_INITIALIZER(MuttrcStack)
	LIFO designed to contain the list of config files that have been sourced and avoid cyclic sourcing.

static const struct Command	MuttCommands []
	General NeoMutt Commands.

Detailed Description

Functions to parse commands in a config file.

Authors

Michael R. Elkins
g10 Code GmbH
Richard Russon
Aditya De Saha
Matthew Hughes
R Primus
Pietro Cerutti
Marco Sirabella
Dennis Schön

Copyright: This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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 commands.c.

Macro Definition Documentation

◆ MAX_ERRS

#define MAX_ERRS 128

Definition at line 78 of file commands.c.

Enumeration Type Documentation

◆ TriBool

enum TriBool

Tri-state boolean.

Enumerator
TB_UNSET	Value hasn't been set.
TB_FALSE	Value is false.
TB_TRUE	Value is true.

Definition at line 83 of file commands.c.

{
  TB_UNSET = -1, 
  TB_FALSE,      
  TB_TRUE,       
};

◆ GroupState

enum GroupState

Type of email address group.

Enumerator
GS_NONE	Group is missing an argument.
GS_RX	Entry is a regular expression.
GS_ADDR	Entry is an address.

Definition at line 93 of file commands.c.

{
  GS_NONE, 
  GS_RX,   
  GS_ADDR, 
};

Function Documentation

◆ is_function()

static bool is_function ( const char * name )

static

Is the argument a neomutt function?

Parameters

name	Command name to be searched for

Return values

true	Function found
false	Function not found

Definition at line 106 of file commands.c.

{
  for (size_t i = 0; MenuNames[i].name; i++)
  {
    const struct MenuFuncOp *fns = km_get_table(MenuNames[i].value);
    if (!fns)
      continue;
 
    for (int j = 0; fns[j].name; j++)
      if (mutt_str_equal(name, fns[j].name))
        return true;
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_grouplist()

int parse_grouplist	(	struct GroupList *	gl,
		struct Buffer *	buf,
		struct Buffer *	s,
		struct Buffer *	err
	)

Parse a group context.

Parameters

gl	GroupList to add to
buf	Temporary Buffer space
s	Buffer containing string to be parsed
err	Buffer for error messages

Return values

0	Success
-1	Error

Definition at line 130 of file commands.c.

{
  while (mutt_istr_equal(buf->data, "-group"))
  {
    if (!MoreArgs(s))
    {
      buf_strcpy(err, _("-group: no group name"));
      return -1;
    }
 
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    mutt_grouplist_add(gl, mutt_pattern_group(buf->data));
 
    if (!MoreArgs(s))
    {
      buf_strcpy(err, _("out of arguments"));
      return -1;
    }
 
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_rc_line_cwd()

enum CommandResult parse_rc_line_cwd	(	const char *	line,
		char *	cwd,
		struct Buffer *	err
	)

Parse and run a muttrc line in a relative directory.

Parameters

line	Line to be parsed
cwd	File relative where to run the line
err	Where to write error messages

Return values

CommandResult Result e.g. MUTT_CMD_SUCCESS

Definition at line 164 of file commands.c.

{
  mutt_list_insert_head(&MuttrcStack, mutt_str_dup(NONULL(cwd)));
 
  enum CommandResult ret = parse_rc_line(line, err);
 
  struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
  STAILQ_REMOVE_HEAD(&MuttrcStack, entries);
  FREE(&np->data);
  FREE(&np);
 
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mutt_get_sourced_cwd()

char * mutt_get_sourced_cwd ( void )

Get the current file path that is being parsed.

Return values

ptr	File path that is being parsed or cwd at runtime

Note: Caller is responsible for freeing returned string

Definition at line 184 of file commands.c.

{
  struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
  if (np && np->data)
    return mutt_str_dup(np->data);
 
  // stack is empty, return our own dummy file relative to cwd
  struct Buffer *cwd = buf_pool_get();
  mutt_path_getcwd(cwd);
  buf_addstr(cwd, "/dummy.rc");
  char *ret = buf_strdup(cwd);
  buf_pool_release(&cwd);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ source_rc()

int source_rc	(	const char *	rcfile_path,
		struct Buffer *	err
	)

Read an initialization file.

Parameters

rcfile_path	Path to initialization file
err	Buffer for error messages

Return values

<0	NeoMutt should pause to let the user know

Definition at line 205 of file commands.c.

{
  int lineno = 0, rc = 0, warnings = 0;
  enum CommandResult line_rc;
  struct Buffer *token = NULL, *linebuf = NULL;
  char *line = NULL;
  char *currentline = NULL;
  char rcfile[PATH_MAX] = { 0 };
  size_t linelen = 0;
  pid_t pid;
 
  mutt_str_copy(rcfile, rcfile_path, sizeof(rcfile));
 
  size_t rcfilelen = mutt_str_len(rcfile);
  if (rcfilelen == 0)
    return -1;
 
  bool ispipe = rcfile[rcfilelen - 1] == '|';
 
  if (!ispipe)
  {
    struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
    if (!mutt_path_to_absolute(rcfile, np ? NONULL(np->data) : ""))
    {
      mutt_error(_("Error: Can't build path of '%s'"), rcfile_path);
      return -1;
    }
 
    STAILQ_FOREACH(np, &MuttrcStack, entries)
    {
      if (mutt_str_equal(np->data, rcfile))
      {
        break;
      }
    }
    if (np)
    {
      mutt_error(_("Error: Cyclic sourcing of configuration file '%s'"), rcfile);
      return -1;
    }
 
    mutt_list_insert_head(&MuttrcStack, mutt_str_dup(rcfile));
  }
 
  mutt_debug(LL_DEBUG2, "Reading configuration file '%s'\n", rcfile);
 
  FILE *fp = mutt_open_read(rcfile, &pid);
  if (!fp)
  {
    buf_printf(err, "%s: %s", rcfile, strerror(errno));
    return -1;
  }
 
  token = buf_pool_get();
  linebuf = buf_pool_get();
 
  const char *const c_config_charset = cs_subset_string(NeoMutt->sub, "config_charset");
  const char *const c_charset = cc_charset();
  while ((line = mutt_file_read_line(line, &linelen, fp, &lineno, MUTT_RL_CONT)) != NULL)
  {
    const bool conv = c_config_charset && c_charset;
    if (conv)
    {
      currentline = mutt_str_dup(line);
      if (!currentline)
        continue;
      mutt_ch_convert_string(&currentline, c_config_charset, c_charset, MUTT_ICONV_NO_FLAGS);
    }
    else
    {
      currentline = line;
    }
 
    buf_strcpy(linebuf, currentline);
 
    buf_reset(err);
    line_rc = parse_rc_buffer(linebuf, token, err);
    if (line_rc == MUTT_CMD_ERROR)
    {
      mutt_error("%s:%d: %s", rcfile, lineno, buf_string(err));
      if (--rc < -MAX_ERRS)
      {
        if (conv)
          FREE(&currentline);
        break;
      }
    }
    else if (line_rc == MUTT_CMD_WARNING)
    {
      /* Warning */
      mutt_warning("%s:%d: %s", rcfile, lineno, buf_string(err));
      warnings++;
    }
    else if (line_rc == MUTT_CMD_FINISH)
    {
      if (conv)
        FREE(&currentline);
      break; /* Found "finish" command */
    }
    else
    {
      if (rc < 0)
        rc = -1;
    }
    if (conv)
      FREE(&currentline);
  }
 
  FREE(&line);
  mutt_file_fclose(&fp);
  if (pid != -1)
    filter_wait(pid);
 
  if (rc)
  {
    /* the neomuttrc source keyword */
    buf_reset(err);
    buf_printf(err, (rc >= -MAX_ERRS) ? _("source: errors in %s") : _("source: reading aborted due to too many errors in %s"),
               rcfile);
    rc = -1;
  }
  else
  {
    /* Don't alias errors with warnings */
    if (warnings > 0)
    {
      buf_printf(err, ngettext("source: %d warning in %s", "source: %d warnings in %s", warnings),
                 warnings, rcfile);
      rc = -2;
    }
  }
 
  if (!ispipe && !STAILQ_EMPTY(&MuttrcStack))
  {
    struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
    STAILQ_REMOVE_HEAD(&MuttrcStack, entries);
    FREE(&np->data);
    FREE(&np);
  }
 
  buf_pool_release(&token);
  buf_pool_release(&linebuf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mailbox_add()

static enum CommandResult mailbox_add	(	const char *	folder,
		const char *	mailbox,
		const char *	label,
		enum TriBool	poll,
		enum TriBool	notify,
		struct Buffer *	err
	)

static

Add a new Mailbox.

Parameters

folder	Path to use for '+' abbreviations
mailbox	Mailbox to add
label	Descriptive label
poll	Enable mailbox polling?
notify	Enable mailbox notification?
err	Buffer for error messages

Return values

CommandResult Result e.g. MUTT_CMD_SUCCESS

Definition at line 622 of file commands.c.

{
  mutt_debug(LL_DEBUG1, "Adding mailbox: '%s' label '%s', poll %s, notify %s\n",
             mailbox, label ? label : "[NONE]",
             (poll == TB_UNSET) ? "[UNSPECIFIED]" :
             (poll == TB_TRUE)  ? "true" :
                                  "false",
             (notify == TB_UNSET) ? "[UNSPECIFIED]" :
             (notify == TB_TRUE)  ? "true" :
                                    "false");
  struct Mailbox *m = mailbox_new();
 
  buf_strcpy(&m->pathbuf, mailbox);
  /* int rc = */ mx_path_canon2(m, folder);
 
  if (m->type <= MUTT_UNKNOWN)
  {
    buf_printf(err, "Unknown Mailbox: %s", m->realpath);
    mailbox_free(&m);
    return MUTT_CMD_ERROR;
  }
 
  bool new_account = false;
  struct Account *a = mx_ac_find(m);
  if (!a)
  {
    a = account_new(NULL, NeoMutt->sub);
    a->type = m->type;
    new_account = true;
  }
 
  if (!new_account)
  {
    struct Mailbox *m_old = mx_mbox_find(a, m->realpath);
    if (m_old)
    {
      if (!m_old->visible)
      {
        m_old->visible = true;
        m_old->gen = mailbox_gen();
      }
 
      if (label)
        mutt_str_replace(&m_old->name, label);
 
      if (notify != TB_UNSET)
        m_old->notify_user = notify;
 
      if (poll != TB_UNSET)
        m_old->poll_new_mail = poll;
 
      struct EventMailbox ev_m = { m_old };
      notify_send(m_old->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
 
      mailbox_free(&m);
      return MUTT_CMD_SUCCESS;
    }
  }
 
  if (label)
    m->name = mutt_str_dup(label);
 
  if (notify != TB_UNSET)
    m->notify_user = notify;
 
  if (poll != TB_UNSET)
    m->poll_new_mail = poll;
 
  if (!mx_ac_add(a, m))
  {
    mailbox_free(&m);
    if (new_account)
    {
      cs_subset_free(&a->sub);
      FREE(&a->name);
      notify_free(&a->notify);
      FREE(&a);
    }
    return MUTT_CMD_SUCCESS;
  }
 
  if (new_account)
  {
    neomutt_account_add(NeoMutt, a);
  }
 
  // this is finally a visible mailbox in the sidebar and mailboxes list
  m->visible = true;
 
#ifdef USE_INOTIFY
  mutt_monitor_add(m);
#endif
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mailbox_add_simple()

bool mailbox_add_simple	(	const char *	mailbox,
		struct Buffer *	err
	)

Add a new Mailbox.

Parameters

mailbox	Mailbox to add
err	Buffer for error messages

Return values

true Success

Definition at line 726 of file commands.c.

{
  enum CommandResult rc = mailbox_add("", mailbox, NULL, TB_UNSET, TB_UNSET, err);
 
  return (rc == MUTT_CMD_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_dump()

enum CommandResult set_dump	(	ConfigDumpFlags	flags,
		struct Buffer *	err
	)

Dump list of config variables into a file/pager.

Parameters

flags	what configs to dump: see ConfigDumpFlags
err	buffer for error message

Returns: num See CommandResult

FIXME: Move me into parse/set.c. Note: this function currently depends on pager, which is the reason it is not included in the parse library.

Definition at line 873 of file commands.c.

{
  struct Buffer *tempfile = buf_pool_get();
  buf_mktemp(tempfile);
 
  FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_out)
  {
    // L10N: '%s' is the file name of the temporary file
    buf_printf(err, _("Could not create temporary file %s"), buf_string(tempfile));
    buf_pool_release(&tempfile);
    return MUTT_CMD_ERROR;
  }
 
  dump_config(NeoMutt->sub->cs, flags, fp_out);
 
  mutt_file_fclose(&fp_out);
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pdata.fname = buf_string(tempfile);
 
  pview.banner = "set";
  pview.flags = MUTT_PAGER_NO_FLAGS;
  pview.mode = PAGER_MODE_OTHER;
 
  mutt_do_pager(&pview, NULL);
  buf_pool_release(&tempfile);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_unmailboxes()

static void do_unmailboxes ( struct Mailbox * m )

static

Remove a Mailbox from the Sidebar/notifications.

Parameters

m	Mailbox to `unmailboxes`

Definition at line 1400 of file commands.c.

{
#ifdef USE_INOTIFY
  if (m->poll_new_mail)
    mutt_monitor_remove(m);
#endif
  m->visible = false;
  m->gen = -1;
  if (m->opened)
  {
    struct EventMailbox ev_m = { NULL };
    mutt_debug(LL_NOTIFY, "NT_MAILBOX_CHANGE: NULL\n");
    notify_send(NeoMutt->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
  }
  else
  {
    account_mailbox_remove(m->account, m);
    mailbox_free(&m);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_unmailboxes_star()

static void do_unmailboxes_star ( void )

static

Remove all Mailboxes from the Sidebar/notifications.

Definition at line 1424 of file commands.c.

{
  struct MailboxList ml = STAILQ_HEAD_INITIALIZER(ml);
  neomutt_mailboxlist_get_all(&ml, NeoMutt, MUTT_MAILBOX_ANY);
  struct MailboxNode *np = NULL;
  struct MailboxNode *nptmp = NULL;
  STAILQ_FOREACH_SAFE(np, &ml, entries, nptmp)
  {
    do_unmailboxes(np->mailbox);
  }
  neomutt_mailboxlist_clear(&ml);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ source_stack_cleanup()

void source_stack_cleanup ( void )

Free memory from the stack used for the source command.

Definition at line 1647 of file commands.c.

{
  mutt_list_free(&MuttrcStack);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ commands_init()

void commands_init ( void )

Initialize commands array and register default commands.

Definition at line 1723 of file commands.c.

{
  commands_register(MuttCommands, mutt_array_size(MuttCommands));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ MuttrcStack

struct ListHead MuttrcStack = STAILQ_HEAD_INITIALIZER(MuttrcStack)

static

LIFO designed to contain the list of config files that have been sourced and avoid cyclic sourcing.

Definition at line 76 of file commands.c.

◆ MuttCommands

const struct Command MuttCommands[]

static

General NeoMutt Commands.

Definition at line 1655 of file commands.c.

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ MAX_ERRS

Enumeration Type Documentation

◆ TriBool

◆ GroupState

Function Documentation

◆ is_function()

◆ parse_grouplist()

◆ parse_rc_line_cwd()

◆ mutt_get_sourced_cwd()

◆ source_rc()

◆ mailbox_add()

◆ mailbox_add_simple()

◆ set_dump()

◆ do_unmailboxes()

◆ do_unmailboxes_star()

◆ source_stack_cleanup()

◆ commands_init()

Variable Documentation

◆ MuttrcStack

◆ MuttCommands