commands.c File Reference

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 <sys/types.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?
static bool	is_color_object (const char *name)
	Is the argument a neomutt colour?
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 (enum GetElemListFlags 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.
bool	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 79 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 84 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 94 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 107 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:

is_color_object()

static bool is_color_object ( const char * name )

static

Is the argument a neomutt colour?

Parameters

name	Colour name to be searched for

Return values

true	Function found
false	Function not found

Definition at line 128 of file commands.c.

{
  int cid = mutt_map_get_value(name, ColorFields);
 
  return (cid > 0);
}

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 144 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 178 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 198 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 219 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 + 1] = { 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 637 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 741 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	(	enum GetElemListFlags	flags,
		struct Buffer *	err )

Dump list of config variables into a file/pager.

Parameters

flags	Which config to dump, e.g. GEL_CHANGED_CONFIG
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 888 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;
  }
 
  struct ConfigSet *cs = NeoMutt->sub->cs;
  struct HashElemArray hea = get_elem_list(cs, flags);
  dump_config(cs, &hea, CS_DUMP_NO_FLAGS, fp_out);
  ARRAY_FREE(&hea);
 
  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 1423 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 1447 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 1671 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()

bool commands_init

(

void

)

Initialize commands array and register default commands.

Definition at line 1748 of file commands.c.

{
  return commands_register(&NeoMutt->commands, 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 77 of file commands.c.

MuttCommands

const struct Command MuttCommands[]

static

General NeoMutt Commands.

Definition at line 1679 of file commands.c.

                                             {
  // clang-format off
  { "alias",               parse_alias,            0 },
  { "alternates",          parse_alternates,       0 },
  { "alternative_order",   parse_stailq,           IP &AlternativeOrderList },
  { "attachments",         parse_attachments,      0 },
  { "auto_view",           parse_stailq,           IP &AutoViewList },
  { "bind",                parse_bind,             0 },
  { "cd",                  parse_cd,               0 },
  { "color",               parse_color,            0 },
  { "echo",                parse_echo,             0 },
  { "exec",                parse_exec,             0 },
  { "finish",              parse_finish,           0 },
  { "group",               parse_group,            MUTT_GROUP },
  { "hdr_order",           parse_stailq,           IP &HeaderOrderList },
  { "ifdef",               parse_ifdef,            0 },
  { "ifndef",              parse_ifdef,            1 },
  { "ignore",              parse_ignore,           0 },
  { "lists",               parse_lists,            0 },
  { "macro",               parse_macro,            1 },
  { "mailboxes",           parse_mailboxes,        0 },
  { "mailto_allow",        parse_stailq,           IP &MailToAllow },
  { "mime_lookup",         parse_stailq,           IP &MimeLookupList },
  { "mono",                parse_mono,             0 },
  { "my_hdr",              parse_my_hdr,           0 },
  { "named-mailboxes",     parse_mailboxes,        MUTT_NAMED },
  { "nospam",              parse_nospam,           0 },
  { "push",                parse_push,             0 },
  { "reset",               parse_set,              MUTT_SET_RESET },
  { "score",               parse_score,            0 },
  { "set",                 parse_set,              MUTT_SET_SET },
  { "setenv",              parse_setenv,           MUTT_SET_SET },
  { "source",              parse_source,           0 },
  { "spam",                parse_spam,             0 },
  { "subjectrx",           parse_subjectrx_list,   0 },
  { "subscribe",           parse_subscribe,        0 },
  { "tag-formats",         parse_tag_formats,      0 },
  { "tag-transforms",      parse_tag_transforms,   0 },
  { "toggle",              parse_set,              MUTT_SET_INV },
  { "unalias",             parse_unalias,          0 },
  { "unalternates",        parse_unalternates,     0 },
  { "unalternative_order", parse_unstailq,         IP &AlternativeOrderList },
  { "unattachments",       parse_unattachments,    0 },
  { "unauto_view",         parse_unstailq,         IP &AutoViewList },
  { "unbind",              parse_unbind,           MUTT_UNBIND },
  { "uncolor",             parse_uncolor,          0 },
  { "ungroup",             parse_group,            MUTT_UNGROUP },
  { "unhdr_order",         parse_unstailq,         IP &HeaderOrderList },
  { "unignore",            parse_unignore,         0 },
  { "unlists",             parse_unlists,          0 },
  { "unmacro",             parse_unbind,           MUTT_UNMACRO },
  { "unmailboxes",         parse_unmailboxes,      0 },
  { "unmailto_allow",      parse_unstailq,         IP &MailToAllow },
  { "unmime_lookup",       parse_unstailq,         IP &MimeLookupList },
  { "unmono",              parse_unmono,           0 },
  { "unmy_hdr",            parse_unmy_hdr,         0 },
  { "unscore",             parse_unscore,          0 },
  { "unset",               parse_set,              MUTT_SET_UNSET },
  { "unsetenv",            parse_setenv,           MUTT_SET_UNSET },
  { "unsubjectrx",         parse_unsubjectrx_list, 0 },
  { "unsubscribe",         parse_unsubscribe,      0 },
  { "version",             parse_version,          0 },
  { NULL, NULL, 0 },
  // clang-format on
};