commands.c

Go to the documentation of this file.

 
#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"
#ifdef USE_INOTIFY
#include "monitor.h"
#endif
#ifdef ENABLE_NLS
#include <libintl.h>
#endif

static struct ListHead MuttrcStack = STAILQ_HEAD_INITIALIZER(MuttrcStack);
 
#define MAX_ERRS 128

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

enum GroupState
{
  GS_NONE, 
  GS_RX,   
  GS_ADDR, 
};

static bool is_function(const char *name)
{
  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;
}

static bool is_color_object(const char *name)
{
  int cid = mutt_map_get_value(name, ColorFields);
 
  return (cid > 0);
}

int parse_grouplist(struct GroupList *gl, struct Buffer *token, struct Buffer *line,
                    struct Buffer *err, struct HashTable *groups)
{
  while (mutt_istr_equal(token->data, "-group"))
  {
    if (!MoreArgs(line))
    {
      buf_strcpy(err, _("-group: no group name"));
      return -1;
    }
 
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    grouplist_add_group(gl, groups_get_group(groups, token->data));
 
    if (!MoreArgs(line))
    {
      buf_strcpy(err, _("out of arguments"));
      return -1;
    }
 
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
  }
 
  return 0;
}

enum CommandResult parse_rc_line_cwd(const char *line, char *cwd, struct Buffer *err)
{
  mutt_list_insert_head(&MuttrcStack, mutt_str_dup(NONULL(cwd)));
 
  struct Buffer *buf = buf_pool_get();
  buf_strcpy(buf, line);
  enum CommandResult ret = parse_rc_line(buf, err);
  buf_pool_release(&buf);
 
  struct ListNode *np = STAILQ_FIRST(&MuttrcStack);
  STAILQ_REMOVE_HEAD(&MuttrcStack, entries);
  FREE(&np->data);
  FREE(&np);
 
  return ret;
}

char *mutt_get_sourced_cwd(void)
{
  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;
}

int source_rc(const char *rcfile_path, struct Buffer *err)
{
  int lineno = 0, rc = 0, warnings = 0;
  enum CommandResult line_rc;
  struct Buffer *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;
  }
 
  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_line(linebuf, 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(&linebuf);
  return rc;
}

enum CommandResult parse_cd(const struct Command *cmd, struct Buffer *line, struct Buffer *err)
{
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
  if (buf_is_empty(token))
  {
    buf_strcpy(token, NeoMutt->home_dir);
  }
  else
  {
    buf_expand_path(token);
  }
 
  if (chdir(buf_string(token)) != 0)
  {
    buf_printf(err, "%s: %s", cmd->name, strerror(errno));
    goto done;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_echo(const struct Command *cmd, struct Buffer *line,
                              struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
  OptForceRefresh = true;
  mutt_message("%s", buf_string(token));
  OptForceRefresh = false;
  mutt_sleep(0);
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_finish(const struct Command *cmd, struct Buffer *line,
                                struct Buffer *err)
{
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  return MUTT_CMD_FINISH;
}

enum CommandResult parse_group(const struct Command *cmd, struct Buffer *line,
                               struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  enum GroupState gstate = GS_NONE;
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    if (parse_grouplist(&gl, token, line, err, NeoMutt->groups) == -1)
      goto done;
 
    if ((cmd->data == MUTT_UNGROUP) && mutt_istr_equal(buf_string(token), "*"))
    {
      groups_remove_grouplist(NeoMutt->groups, &gl);
      rc = MUTT_CMD_SUCCESS;
      goto done;
    }
 
    if (mutt_istr_equal(buf_string(token), "-rx"))
    {
      gstate = GS_RX;
    }
    else if (mutt_istr_equal(buf_string(token), "-addr"))
    {
      gstate = GS_ADDR;
    }
    else
    {
      switch (gstate)
      {
        case GS_NONE:
          buf_printf(err, _("%s: missing -rx or -addr"), cmd->name);
          rc = MUTT_CMD_WARNING;
          goto done;
 
        case GS_RX:
          if ((cmd->data == MUTT_GROUP) &&
              (grouplist_add_regex(&gl, buf_string(token), REG_ICASE, err) != 0))
          {
            goto done;
          }
          else if ((cmd->data == MUTT_UNGROUP) &&
                   (groups_remove_regex(NeoMutt->groups, &gl, buf_string(token)) < 0))
          {
            goto done;
          }
          break;
 
        case GS_ADDR:
        {
          char *estr = NULL;
          struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
          mutt_addrlist_parse2(&al, buf_string(token));
          if (TAILQ_EMPTY(&al))
            goto done;
          if (mutt_addrlist_to_intl(&al, &estr))
          {
            buf_printf(err, _("%s: warning: bad IDN '%s'"), cmd->name, estr);
            mutt_addrlist_clear(&al);
            FREE(&estr);
            goto done;
          }
          if (cmd->data == MUTT_GROUP)
            grouplist_add_addrlist(&gl, &al);
          else if (cmd->data == MUTT_UNGROUP)
            groups_remove_addrlist(NeoMutt->groups, &gl, &al);
          mutt_addrlist_clear(&al);
          break;
        }
      }
    }
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  grouplist_destroy(&gl);
  return rc;
}

enum CommandResult parse_ifdef(const struct Command *cmd, struct Buffer *line,
                               struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_SUCCESS;
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
  // is the item defined as:
  bool res = cs_subset_lookup(NeoMutt->sub, buf_string(token)) // a variable?
             || feature_enabled(buf_string(token)) // a compiled-in feature?
             || is_function(buf_string(token))     // a function?
             || commands_get(&NeoMutt->commands, buf_string(token)) // a command?
             || is_color_object(buf_string(token))                  // a color?
#ifdef USE_HCACHE
             || store_is_valid_backend(buf_string(token)) // a store? (database)
#endif
             || mutt_str_getenv(buf_string(token)); // an environment variable?
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto done;
  }
  parse_extract_token(token, line, TOKEN_SPACE);
 
  /* ifdef KNOWN_SYMBOL or ifndef UNKNOWN_SYMBOL */
  if ((res && (cmd->data == 0)) || (!res && (cmd->data == 1)))
  {
    rc = parse_rc_line(token, err);
    if (rc == MUTT_CMD_ERROR)
      mutt_error(_("Error: %s"), buf_string(err));
 
    goto done;
  }
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_ignore(const struct Command *cmd, struct Buffer *line,
                                struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    remove_from_stailq(&UnIgnore, buf_string(token));
    add_to_stailq(&Ignore, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_lists(const struct Command *cmd, struct Buffer *line,
                               struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, token, line, err, NeoMutt->groups) == -1)
      goto done;
 
    mutt_regexlist_remove(&UnMailLists, buf_string(token));
 
    if (mutt_regexlist_add(&MailLists, buf_string(token), REG_ICASE, err) != 0)
      goto done;
 
    if (grouplist_add_regex(&gl, buf_string(token), REG_ICASE, err) != 0)
      goto done;
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  grouplist_destroy(&gl);
  return rc;
}

static enum CommandResult mailbox_add(const char *folder, const char *mailbox,
                                      const char *label, enum TriBool poll,
                                      enum TriBool notify, struct Buffer *err)
{
  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;
}

bool mailbox_add_simple(const char *mailbox, struct Buffer *err)
{
  enum CommandResult rc = mailbox_add("", mailbox, NULL, TB_UNSET, TB_UNSET, err);
 
  return (rc == MUTT_CMD_SUCCESS);
}

enum CommandResult parse_mailboxes(const struct Command *cmd,
                                   struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *label = buf_pool_get();
  struct Buffer *mailbox = buf_pool_get();
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
  while (MoreArgs(line))
  {
    bool label_set = false;
    enum TriBool notify = TB_UNSET;
    enum TriBool poll = TB_UNSET;
 
    do
    {
      // Start by handling the options
      parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
      if (mutt_str_equal(buf_string(token), "-label"))
      {
        if (!MoreArgs(line))
        {
          buf_printf(err, _("%s: too few arguments"), "mailboxes -label");
          goto done;
        }
 
        parse_extract_token(label, line, TOKEN_NO_FLAGS);
        label_set = true;
      }
      else if (mutt_str_equal(buf_string(token), "-nolabel"))
      {
        buf_reset(label);
        label_set = true;
      }
      else if (mutt_str_equal(buf_string(token), "-notify"))
      {
        notify = TB_TRUE;
      }
      else if (mutt_str_equal(buf_string(token), "-nonotify"))
      {
        notify = TB_FALSE;
      }
      else if (mutt_str_equal(buf_string(token), "-poll"))
      {
        poll = TB_TRUE;
      }
      else if (mutt_str_equal(buf_string(token), "-nopoll"))
      {
        poll = TB_FALSE;
      }
      else if ((cmd->data & MUTT_NAMED) && !label_set)
      {
        if (!MoreArgs(line))
        {
          buf_printf(err, _("%s: too few arguments"), cmd->name);
          goto done;
        }
 
        buf_copy(label, token);
        label_set = true;
      }
      else
      {
        buf_copy(mailbox, token);
        break;
      }
    } while (MoreArgs(line));
 
    if (buf_is_empty(mailbox))
    {
      buf_printf(err, _("%s: too few arguments"), cmd->name);
      goto done;
    }
 
    rc = mailbox_add(c_folder, buf_string(mailbox),
                     label_set ? buf_string(label) : NULL, poll, notify, err);
    if (rc != MUTT_CMD_SUCCESS)
      goto done;
 
    buf_reset(label);
    buf_reset(mailbox);
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&label);
  buf_pool_release(&mailbox);
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_my_hdr(const struct Command *cmd, struct Buffer *line,
                                struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  parse_extract_token(token, line, TOKEN_SPACE | TOKEN_QUOTE);
  char *p = strpbrk(buf_string(token), ": \t");
  if (!p || (*p != ':'))
  {
    buf_strcpy(err, _("invalid header field"));
    goto done;
  }
 
  struct EventHeader ev_h = { token->data };
  struct ListNode *node = header_find(&UserHeader, buf_string(token));
 
  if (node)
  {
    header_update(node, buf_string(token));
    mutt_debug(LL_NOTIFY, "NT_HEADER_CHANGE: %s\n", buf_string(token));
    notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_CHANGE, &ev_h);
  }
  else
  {
    header_add(&UserHeader, buf_string(token));
    mutt_debug(LL_NOTIFY, "NT_HEADER_ADD: %s\n", buf_string(token));
    notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_ADD, &ev_h);
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult set_dump(enum GetElemListFlags flags, struct Buffer *err)
{
  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;
}

static int envlist_sort(const void *a, const void *b, void *sdata)
{
  return strcmp(*(const char **) a, *(const char **) b);
}

enum CommandResult parse_setenv(const struct Command *cmd, struct Buffer *line,
                                struct Buffer *err)
{
  struct Buffer *token = buf_pool_get();
  struct Buffer *tempfile = NULL;
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  char **envp = NeoMutt->env;
 
  bool query = false;
  bool prefix = false;
  bool unset = (cmd->data == MUTT_SET_UNSET);
 
  if (!MoreArgs(line))
  {
    if (!StartupComplete)
    {
      buf_printf(err, _("%s: too few arguments"), cmd->name);
      goto done;
    }
 
    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));
      rc = MUTT_CMD_ERROR;
      goto done;
    }
 
    int count = 0;
    for (char **env = NeoMutt->env; *env; env++)
      count++;
 
    mutt_qsort_r(NeoMutt->env, count, sizeof(char *), envlist_sort, NULL);
 
    for (char **env = NeoMutt->env; *env; env++)
      fprintf(fp_out, "%s\n", *env);
 
    mutt_file_fclose(&fp_out);
 
    struct PagerData pdata = { 0 };
    struct PagerView pview = { &pdata };
 
    pdata.fname = buf_string(tempfile);
 
    pview.banner = cmd->name;
    pview.flags = MUTT_PAGER_NO_FLAGS;
    pview.mode = PAGER_MODE_OTHER;
 
    mutt_do_pager(&pview, NULL);
 
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  if (*line->dptr == '?')
  {
    query = true;
    prefix = true;
 
    if (unset)
    {
      buf_printf(err, _("Can't query option with the '%s' command"), cmd->name);
      goto done;
    }
 
    line->dptr++;
  }
 
  /* get variable name */
  parse_extract_token(token, line, TOKEN_EQUAL | TOKEN_QUESTION);
 
  if (*line->dptr == '?')
  {
    if (unset)
    {
      buf_printf(err, _("Can't query option with the '%s' command"), cmd->name);
      goto done;
    }
 
    if (prefix)
    {
      buf_printf(err, _("Can't use a prefix when querying a variable"));
      goto done;
    }
 
    query = true;
    line->dptr++;
  }
 
  if (query)
  {
    bool found = false;
    while (envp && *envp)
    {
      /* This will display all matches for "^QUERY" */
      if (mutt_str_startswith(*envp, buf_string(token)))
      {
        if (!found)
        {
          mutt_endwin();
          found = true;
        }
        puts(*envp);
      }
      envp++;
    }
 
    if (found)
    {
      mutt_any_key_to_continue(NULL);
      rc = MUTT_CMD_SUCCESS;
      goto done;
    }
 
    buf_printf(err, _("%s is unset"), buf_string(token));
    goto done;
  }
 
  if (unset)
  {
    if (envlist_unset(&NeoMutt->env, buf_string(token)))
      rc = MUTT_CMD_SUCCESS;
    else
      buf_printf(err, _("%s is unset"), buf_string(token));
 
    goto done;
  }
 
  /* set variable */
 
  if (*line->dptr == '=')
  {
    line->dptr++;
    SKIPWS(line->dptr);
  }
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    goto done;
  }
 
  char *varname = mutt_str_dup(buf_string(token));
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
  envlist_set(&NeoMutt->env, varname, buf_string(token), true);
  FREE(&varname);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  buf_pool_release(&tempfile);
  return rc;
}

enum CommandResult parse_source(const struct Command *cmd, struct Buffer *line,
                                struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  struct Buffer *path = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    if (parse_extract_token(token, line, TOKEN_BACKTICK_VARS) != 0)
    {
      buf_printf(err, _("source: error at %s"), line->dptr);
      goto done;
    }
    buf_copy(path, token);
    buf_expand_path(path);
 
    if (source_rc(buf_string(path), err) < 0)
    {
      buf_printf(err, _("source: file %s could not be sourced"), buf_string(path));
      goto done;
    }
 
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&path);
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_nospam(const struct Command *cmd, struct Buffer *line,
                                struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  // Extract the first token, a regex or "*"
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  // "*" is special - clear both spam and nospam lists
  if (mutt_str_equal(buf_string(token), "*"))
  {
    mutt_replacelist_free(&SpamList);
    mutt_regexlist_free(&NoSpamList);
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  // If it's on the spam list, just remove it
  if (mutt_replacelist_remove(&SpamList, buf_string(token)) != 0)
  {
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  // Otherwise, add it to the nospam list
  if (mutt_regexlist_add(&NoSpamList, buf_string(token), REG_ICASE, err) != 0)
  {
    rc = MUTT_CMD_ERROR;
    goto done;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_spam(const struct Command *cmd, struct Buffer *line,
                              struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  struct Buffer *templ = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  // Extract the first token, a regex
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
  // If there's a second parameter, it's a template for the spam tag
  if (MoreArgs(line))
  {
    templ = buf_pool_get();
    parse_extract_token(templ, line, TOKEN_NO_FLAGS);
 
    // Add to the spam list
    if (mutt_replacelist_add(&SpamList, buf_string(token), buf_string(templ), err) != 0)
      goto done;
  }
  else
  {
    // If not, try to remove from the nospam list
    mutt_regexlist_remove(&NoSpamList, buf_string(token));
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&templ);
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_stailq(const struct Command *cmd, struct Buffer *line,
                                struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    add_to_stailq((struct ListHead *) cmd->data, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_subscribe(const struct Command *cmd,
                                   struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, token, line, err, NeoMutt->groups) == -1)
      goto done;
 
    mutt_regexlist_remove(&UnMailLists, buf_string(token));
    mutt_regexlist_remove(&UnSubscribedLists, buf_string(token));
 
    if (mutt_regexlist_add(&MailLists, buf_string(token), REG_ICASE, err) != 0)
      goto done;
 
    if (mutt_regexlist_add(&SubscribedLists, buf_string(token), REG_ICASE, err) != 0)
      goto done;
 
    if (grouplist_add_regex(&gl, buf_string(token), REG_ICASE, err) != 0)
      goto done;
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  grouplist_destroy(&gl);
  return rc;
}

enum CommandResult parse_subscribe_to(const struct Command *cmd,
                                      struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  buf_reset(err);
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  // Expand and subscribe
  buf_expand_path(token);
  if (imap_subscribe(buf_string(token), true) != 0)
  {
    buf_printf(err, _("Could not subscribe to %s"), buf_string(token));
    rc = MUTT_CMD_ERROR;
    goto done;
  }
 
  mutt_message(_("Subscribed to %s"), buf_string(token));
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_tag_formats(const struct Command *cmd,
                                     struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *tag = buf_pool_get();
  struct Buffer *fmt = buf_pool_get();
 
  while (MoreArgs(line))
  {
    parse_extract_token(tag, line, TOKEN_NO_FLAGS);
    if (buf_is_empty(tag))
      continue;
 
    parse_extract_token(fmt, line, TOKEN_NO_FLAGS);
 
    /* avoid duplicates */
    const char *tmp = mutt_hash_find(TagFormats, buf_string(fmt));
    if (tmp)
    {
      mutt_warning(_("tag format '%s' already registered as '%s'"), buf_string(fmt), tmp);
      continue;
    }
 
    mutt_hash_insert(TagFormats, buf_string(fmt), buf_strdup(tag));
  }
 
  buf_pool_release(&tag);
  buf_pool_release(&fmt);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_tag_transforms(const struct Command *cmd,
                                        struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *tag = buf_pool_get();
  struct Buffer *trnbuf = buf_pool_get();
 
  while (MoreArgs(line))
  {
    parse_extract_token(tag, line, TOKEN_NO_FLAGS);
    if (buf_is_empty(tag))
      continue;
 
    parse_extract_token(trnbuf, line, TOKEN_NO_FLAGS);
    const char *trn = buf_string(trnbuf);
 
    /* avoid duplicates */
    const char *tmp = mutt_hash_find(TagTransforms, buf_string(tag));
    if (tmp)
    {
      mutt_warning(_("tag transform '%s' already registered as '%s'"),
                   buf_string(tag), tmp);
      continue;
    }
 
    mutt_hash_insert(TagTransforms, buf_string(tag), mutt_str_dup(trn));
  }
 
  buf_pool_release(&tag);
  buf_pool_release(&trnbuf);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_unignore(const struct Command *cmd,
                                  struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    /* don't add "*" to the unignore list */
    if (!mutt_str_equal(buf_string(token), "*"))
      add_to_stailq(&UnIgnore, buf_string(token));
 
    remove_from_stailq(&Ignore, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_unlists(const struct Command *cmd, struct Buffer *line,
                                 struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  mutt_hash_free(&AutoSubscribeCache);
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&SubscribedLists, buf_string(token));
    mutt_regexlist_remove(&MailLists, buf_string(token));
 
    if (!mutt_str_equal(buf_string(token), "*") &&
        (mutt_regexlist_add(&UnMailLists, buf_string(token), REG_ICASE, err) != 0))
    {
      goto done;
    }
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

static void do_unmailboxes(struct Mailbox *m)
{
#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);
  }
}

static void do_unmailboxes_star(void)
{
  struct MailboxArray ma = neomutt_mailboxes_get(NeoMutt, MUTT_MAILBOX_ANY);
 
  struct Mailbox **mp = NULL;
  ARRAY_FOREACH(mp, &ma)
  {
    do_unmailboxes(*mp);
  }
  ARRAY_FREE(&ma); // Clean up the ARRAY, but not the Mailboxes
}

enum CommandResult parse_unmailboxes(const struct Command *cmd,
                                     struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  while (MoreArgs(line))
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (mutt_str_equal(buf_string(token), "*"))
    {
      do_unmailboxes_star();
      goto done;
    }
 
    buf_expand_path(token);
 
    struct Account **ap = NULL;
    ARRAY_FOREACH(ap, &NeoMutt->accounts)
    {
      struct Mailbox *m = mx_mbox_find(*ap, buf_string(token));
      if (m)
      {
        do_unmailboxes(m);
        break;
      }
    }
  }
 
done:
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_unmy_hdr(const struct Command *cmd,
                                  struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  struct ListNode *np = NULL, *tmp = NULL;
  size_t l;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf_string(token)))
    {
      /* Clear all headers, send a notification for each header */
      STAILQ_FOREACH(np, &UserHeader, entries)
      {
        mutt_debug(LL_NOTIFY, "NT_HEADER_DELETE: %s\n", np->data);
        struct EventHeader ev_h = { np->data };
        notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_DELETE, &ev_h);
      }
      mutt_list_free(&UserHeader);
      continue;
    }
 
    l = mutt_str_len(buf_string(token));
    if (buf_at(token, l - 1) == ':')
      l--;
 
    STAILQ_FOREACH_SAFE(np, &UserHeader, entries, tmp)
    {
      if (mutt_istrn_equal(buf_string(token), np->data, l) && (np->data[l] == ':'))
      {
        mutt_debug(LL_NOTIFY, "NT_HEADER_DELETE: %s\n", np->data);
        struct EventHeader ev_h = { np->data };
        notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_DELETE, &ev_h);
 
        header_free(&UserHeader, np);
      }
    }
  } while (MoreArgs(line));
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_unstailq(const struct Command *cmd,
                                  struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    /* Check for deletion of entire list */
    if (mutt_str_equal(buf_string(token), "*"))
    {
      mutt_list_free((struct ListHead *) cmd->data);
      break;
    }
    remove_from_stailq((struct ListHead *) cmd->data, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

enum CommandResult parse_unsubscribe(const struct Command *cmd,
                                     struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  mutt_hash_free(&AutoSubscribeCache);
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&SubscribedLists, buf_string(token));
 
    if (!mutt_str_equal(buf_string(token), "*") &&
        (mutt_regexlist_add(&UnSubscribedLists, buf_string(token), REG_ICASE, err) != 0))
    {
      goto done;
    }
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_unsubscribe_from(const struct Command *cmd,
                                          struct Buffer *line, struct Buffer *err)
{
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  // Expand and unsubscribe
  buf_expand_path(token);
  if (imap_subscribe(buf_string(token), false) != 0)
  {
    buf_printf(err, _("Could not unsubscribe from %s"), buf_string(token));
    rc = MUTT_CMD_ERROR;
    goto done;
  }
 
  mutt_message(_("Unsubscribed from %s"), buf_string(token));
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_version(const struct Command *cmd, struct Buffer *line,
                                 struct Buffer *err)
{
  // silently ignore 'version' if it's in a config file
  if (!StartupComplete)
    return MUTT_CMD_SUCCESS;
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *tempfile = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  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));
    goto done;
  }
 
  print_version(fp_out, false);
  mutt_file_fclose(&fp_out);
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pdata.fname = buf_string(tempfile);
 
  pview.banner = cmd->name;
  pview.flags = MUTT_PAGER_NO_FLAGS;
  pview.mode = PAGER_MODE_OTHER;
 
  mutt_do_pager(&pview, NULL);
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&tempfile);
  return rc;
}

void source_stack_cleanup(void)
{
  mutt_list_free(&MuttrcStack);
}

static const struct Command MuttCommands[] = {
  // clang-format off
  { "alias", parse_alias, 0,
        N_("Define an alias (name to email address)"),
        N_("alias [ -group <name> ... ] <key> <address> [, <address> ... ]"),
        "configuration.html#alias" },
  { "alternates", parse_alternates, 0,
        N_("Define a list of alternate email addresses for the user"),
        N_("alternates [ -group <name> ... ] <regex> [ <regex> ... ]"),
        "configuration.html#alternates" },
  { "alternative_order", parse_stailq, IP &AlternativeOrderList,
        N_("Set preference order for multipart alternatives"),
        N_("alternative_order <mime-type>[/<mime-subtype> ] [ <mime-type>[/<mime-subtype> ] ... ]"),
        "mimesupport.html#alternative-order" },
  { "attachments", parse_attachments, 0,
        N_("Set attachment counting rules"),
        N_("attachments { + | - }<disposition> <mime-type> [ <mime-type> ... ] | ?"),
        "mimesupport.html#attachments" },
  { "auto_view", parse_stailq, IP &AutoViewList,
        N_("Automatically display specified MIME types inline"),
        N_("auto_view <mime-type>[/<mime-subtype> ] [ <mime-type>[/<mime-subtype> ] ... ]"),
        "mimesupport.html#auto-view" },
  { "cd", parse_cd, 0,
        N_("Change NeoMutt's current working directory"),
        N_("cd [ <directory> ]"),
        "configuration.html#cd" },
  { "color", parse_color, 0,
        N_("Define colors for the user interface"),
        N_("color <object> [ <attribute> ... ] <foreground> <background> [ <regex> [ <num> ]]"),
        "configuration.html#color" },
  { "echo", parse_echo, 0,
        N_("Print a message to the status line"),
        N_("echo <message>"),
        "advancedusage.html#echo" },
  { "finish", parse_finish, 0,
        N_("Stop reading current config file"),
        N_("finish "),
        "optionalfeatures.html#ifdef" },
  { "group", parse_group, MUTT_GROUP,
        N_("Add addresses to an address group"),
        N_("group [ -group <name> ... ] { -rx <regex> ... | -addr <address> ... }"),
        "configuration.html#addrgroup" },
  { "hdr_order", parse_stailq, IP &HeaderOrderList,
        N_("Define custom order of headers displayed"),
        N_("hdr_order <header> [ <header> ... ]"),
        "configuration.html#hdr-order" },
  { "ifdef", parse_ifdef, 0,
        N_("Conditionally include config commands if symbol defined"),
        N_("ifdef <symbol> '<config-command> [ <args> ... ]'"),
        "optionalfeatures.html#ifdef" },
  { "ifndef", parse_ifdef, 1,
        N_("Conditionally include if symbol is not defined"),
        N_("ifndef <symbol> '<config-command> [ <args> ... ]'"),
        "optionalfeatures.html#ifdef" },
  { "ignore", parse_ignore, 0,
        N_("Hide specified headers when displaying messages"),
        N_("ignore { * | <string> ... }"),
        "configuration.html#ignore" },
  { "lists", parse_lists, 0,
        N_("Add address to the list of mailing lists"),
        N_("lists [ -group <name> ... ] <regex> [ <regex> ... ]"),
        "configuration.html#lists" },
  { "mailboxes", parse_mailboxes, 0,
        N_("Define a list of mailboxes to watch"),
        N_("mailboxes [[ -label <label> ] | -nolabel ] [[ -notify | -nonotify ] [ -poll | -nopoll ] <mailbox> ] [ ... ]"),
        "configuration.html#mailboxes" },
  { "mailto_allow", parse_stailq, IP &MailToAllow,
        N_("Permit specific header-fields in mailto URL processing"),
        N_("mailto_allow { * | <header-field> ... }"),
        "configuration.html#mailto-allow" },
  { "mime_lookup", parse_stailq, IP &MimeLookupList,
        N_("Map specified MIME types/subtypes to display handlers"),
        N_("mime_lookup <mime-type>[/<mime-subtype> ] [ <mime-type>[/<mime-subtype> ] ... ]"),
        "mimesupport.html#mime-lookup" },
  { "mono", parse_mono, 0,
        N_("**Deprecated**: Use `color`"),
        N_("mono <object> <attribute> [ <pattern> | <regex> ]"),
        "configuration.html#color-mono" },
  { "my_hdr", parse_my_hdr, 0,
        N_("Add a custom header to outgoing messages"),
        N_("my_hdr <string>"),
        "configuration.html#my-hdr" },
  { "named-mailboxes", parse_mailboxes, MUTT_NAMED,
        N_("Define a list of labelled mailboxes to watch"),
        N_("named-mailboxes <description> <mailbox> [ <description> <mailbox> ... ]"),
        "configuration.html#mailboxes" },
  { "nospam", parse_nospam, 0,
        N_("Remove a spam detection rule"),
        N_("nospam { * | <regex> }"),
        "configuration.html#spam" },
  { "reset", parse_set, MUTT_SET_RESET,
        N_("Reset a config option to its initial value"),
        N_("reset <variable> [ <variable> ... ]"),
        "configuration.html#set" },
  { "score", parse_score, 0,
        N_("Set a score value on emails matching a pattern"),
        N_("score <pattern> <value>"),
        "configuration.html#score-command" },
  { "set", parse_set, MUTT_SET_SET,
        N_("Set a config variable"),
        N_("set { [ no | inv | & ] <variable> [?] | <variable> [=|+=|-=] value } [ ... ]"),
        "configuration.html#set" },
  { "setenv", parse_setenv, MUTT_SET_SET,
        N_("Set an environment variable"),
        N_("setenv { <variable>? | <variable> <value> }"),
        "advancedusage.html#setenv" },
  { "source", parse_source, 0,
        N_("Read and execute commands from a config file"),
        N_("source <filename>"),
        "configuration.html#source" },
  { "spam", parse_spam, 0,
        N_("Define rules to parse spam detection headers"),
        N_("spam <regex> <format>"),
        "configuration.html#spam" },
  { "subjectrx", parse_subjectrx_list, 0,
        N_("Apply regex-based rewriting to message subjects"),
        N_("subjectrx <regex> <replacement>"),
        "advancedusage.html#display-munging" },
  { "subscribe", parse_subscribe, 0,
        N_("Add address to the list of subscribed mailing lists"),
        N_("subscribe [ -group <name> ... ] <regex> [ <regex> ... ]"),
        "configuration.html#lists" },
  { "tag-formats", parse_tag_formats, 0,
        N_("Define expandos tags"),
        N_("tag-formats <tag> <format-string> { tag format-string ... }"),
        "optionalfeatures.html#custom-tags" },
  { "tag-transforms", parse_tag_transforms, 0,
        N_("Rules to transform tags into icons"),
        N_("tag-transforms <tag> <transformed-string> { tag transformed-string ... }"),
        "optionalfeatures.html#custom-tags" },
  { "toggle", parse_set, MUTT_SET_INV,
        N_("Toggle the value of a boolean/quad config option"),
        N_("toggle <variable> [ <variable> ... ]"),
        "configuration.html#set" },
  { "unalias", parse_unalias, 0,
        N_("Remove an alias definition"),
        N_("unalias [ -group <name> ... ] { * | <key> ... }"),
        "configuration.html#alias" },
  { "unalternates", parse_unalternates, 0,
        N_("Remove addresses from `alternates` list"),
        N_("unalternates [ -group <name> ... ] { * | <regex> ... }"),
        "configuration.html#alternates" },
  { "unalternative_order", parse_unstailq, IP &AlternativeOrderList,
        N_("Remove MIME types from preference order"),
        N_("unalternative_order { * | [ <mime-type>[/<mime-subtype> ] ... ] }"),
        "mimesupport.html#alternative-order" },
  { "unattachments", parse_unattachments, 0,
        N_("Remove attachment counting rules"),
        N_("unattachments { * | { + | - }<disposition> <mime-type> [ <mime-type> ... ] }"),
        "mimesupport.html#attachments" },
  { "unauto_view", parse_unstailq, IP &AutoViewList,
        N_("Remove MIME types from `auto_view` list"),
        N_("unauto_view { * | [ <mime-type>[/<mime-subtype> ] ... ] }"),
        "mimesupport.html#auto-view" },
  { "uncolor", parse_uncolor, 0,
        N_("Remove a `color` definition"),
        N_("uncolor <object> { * | <pattern> ... }"),
        "configuration.html#color" },
  { "ungroup", parse_group, MUTT_UNGROUP,
        N_("Remove addresses from an address `group`"),
        N_("ungroup [ -group <name> ... ] { * | -rx <regex> ... | -addr <address> ... }"),
        "configuration.html#addrgroup" },
  { "unhdr_order", parse_unstailq, IP &HeaderOrderList,
        N_("Remove header from `hdr_order` list"),
        N_("unhdr_order { * | <header> ... }"),
        "configuration.html#hdr-order" },
  { "unignore", parse_unignore, 0,
        N_("Remove a header from the `hdr_order` list"),
        N_("unignore { * | <string> ... }"),
        "configuration.html#ignore" },
  { "unlists", parse_unlists, 0,
        N_("Remove address from the list of mailing lists"),
        N_("unlists [ -group <name> ... ] { * | <regex> ... }"),
        "configuration.html#lists" },
  { "unmailboxes", parse_unmailboxes, 0,
        N_("Remove mailboxes from the watch list"),
        N_("unmailboxes { * | <mailbox> ... }"),
        "configuration.html#mailboxes" },
  { "unmailto_allow", parse_unstailq, IP &MailToAllow,
        N_("Disallow header-fields in mailto processing"),
        N_("unmailto_allow { * | <header-field> ... }"),
        "configuration.html#mailto-allow" },
  { "unmime_lookup", parse_unstailq, IP &MimeLookupList,
        N_("Remove custom MIME-type handlers"),
        N_("unmime_lookup { * | [ <mime-type>[/<mime-subtype> ] ... ] }"),
        "mimesupport.html#mime-lookup" },
  { "unmono", parse_unmono, 0,
        N_("**Deprecated**: Use `uncolor`"),
        N_("unmono <object> { * | <pattern> ... }"),
        "configuration.html#color-mono" },
  { "unmy_hdr", parse_unmy_hdr, 0,
        N_("Remove a header previously added with `my_hdr`"),
        N_("unmy_hdr { * | <field> ... }"),
        "configuration.html#my-hdr" },
  { "unscore", parse_unscore, 0,
        N_("Remove scoring rules for matching patterns"),
        N_("unscore { * | <pattern> ... }"),
        "configuration.html#score-command" },
  { "unset", parse_set, MUTT_SET_UNSET,
        N_("Reset a config option to false/empty"),
        N_("unset <variable> [ <variable> ... ]"),
        "configuration.html#set" },
  { "unsetenv", parse_setenv, MUTT_SET_UNSET,
        N_("Unset an environment variable"),
        N_("unsetenv <variable>"),
        "advancedusage.html#setenv" },
  { "unsubjectrx", parse_unsubjectrx_list, 0,
        N_("Remove subject-rewriting rules"),
        N_("unsubjectrx { * | <regex> }"),
        "advancedusage.html#display-munging" },
  { "unsubscribe", parse_unsubscribe, 0,
        N_("Remove address from the list of subscribed mailing lists"),
        N_("unsubscribe [ -group <name> ... ] { * | <regex> ... }"),
        "configuration.html#lists" },
  { "version", parse_version, 0,
        N_("Show NeoMutt version and build information"),
        N_("version "),
        "configuration.html#version" },
 
  { NULL, NULL, 0, NULL, NULL, NULL, CF_NO_FLAGS },
  // clang-format on
};

bool commands_init(void)
{
  return commands_register(&NeoMutt->commands, MuttCommands);
}