parse()

Function to parse a command. More...

Collaboration diagram for parse():

Functions
enum CommandResult	parse_alternates (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'alternates' command - Implements Command::parse() -.
enum CommandResult	parse_unalternates (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unalternates' command - Implements Command::parse() -.
enum CommandResult	parse_alias (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'alias' command - Implements Command::parse() -.
enum CommandResult	parse_unalias (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unalias' command - Implements Command::parse() -.
enum CommandResult	parse_group (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'group' and 'ungroup' commands - Implements Command::parse() -.
enum CommandResult	parse_lists (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'lists' command - Implements Command::parse() -.
enum CommandResult	parse_subscribe (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'subscribe' command - Implements Command::parse() -.
enum CommandResult	parse_unlists (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unlists' command - Implements Command::parse() -.
enum CommandResult	parse_unsubscribe (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unsubscribe' command - Implements Command::parse() -.
enum CommandResult	parse_attachments (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'attachments' command - Implements Command::parse() -.
enum CommandResult	parse_unattachments (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unattachments' command - Implements Command::parse() -.
enum CommandResult	parse_mime_lookup (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'mime-lookup' command - Implements Command::parse() -.
enum CommandResult	parse_unmime_lookup (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unmime-lookup' command - Implements Command::parse() -.
enum CommandResult	parse_uncolor_command (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse an 'uncolor' command - Implements Command::parse() -.
enum CommandResult	parse_uncolor (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'uncolor' command - Implements Command::parse() -.
enum CommandResult	parse_unmono (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unmono' command - Implements Command::parse() -.
enum CommandResult	parse_color (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'color' command - Implements Command::parse() -.
enum CommandResult	parse_mono (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'mono' command - Implements Command::parse() -.
enum CommandResult	parse_ifdef (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'ifdef' and 'ifndef' commands - Implements Command::parse() -.
enum CommandResult	parse_finish (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'finish' command - Implements Command::parse() -.
enum CommandResult	parse_mailboxes (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'mailboxes' command - Implements Command::parse() -.
enum CommandResult	parse_unmailboxes (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unmailboxes' command - Implements Command::parse() -.
enum CommandResult	parse_cd (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'cd' command - Implements Command::parse() -.
enum CommandResult	parse_echo (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'echo' command - Implements Command::parse() -.
enum CommandResult	parse_version (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'version' command - Implements Command::parse() -.
enum CommandResult	parse_setenv (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'setenv' and 'unsetenv' commands - Implements Command::parse() -.
enum CommandResult	parse_source (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'source' command - Implements Command::parse() -.
enum CommandResult	parse_stailq (const struct Command *cmd, struct Buffer *line, struct ListHead *list, const struct ParseContext *pc, struct ParseError *pe)
	Parse a list command - Implements Command::parse() -.
enum CommandResult	parse_unstailq (const struct Command *cmd, struct Buffer *line, struct ListHead *list, const struct ParseContext *pc, struct ParseError *pe)
	Parse an unlist command - Implements Command::parse() -.
enum CommandResult	parse_list (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse a list command - Implements Command::parse() -.
enum CommandResult	parse_unlist (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse an unlist command - Implements Command::parse() -.
enum CommandResult	parse_tag_formats (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'tag-formats' command - Implements Command::parse() -.
enum CommandResult	parse_tag_transforms (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'tag-transforms' command - Implements Command::parse() -.
enum CommandResult	parse_ignore (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'ignore' command - Implements Command::parse() -.
enum CommandResult	parse_unignore (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unignore' command - Implements Command::parse() -.
enum CommandResult	parse_score (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'score' command - Implements Command::parse() -.
enum CommandResult	parse_unscore (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unscore' command - Implements Command::parse() -.
enum CommandResult	parse_nospam (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'nospam' command - Implements Command::parse() -.
enum CommandResult	parse_spam (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'spam' command - Implements Command::parse() -.
enum CommandResult	parse_hooks (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'hooks' command - Implements Command::parse() -.
enum CommandResult	parse_charset_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse charset Hook commands - Implements Command::parse() -.
enum CommandResult	parse_global_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse global Hook commands - Implements Command::parse() -.
enum CommandResult	parse_pattern_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse pattern-based Hook commands - Implements Command::parse() -.
enum CommandResult	parse_mailbox_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse mailbox pattern hook commands - Implements Command::parse() -.
enum CommandResult	parse_regex_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse regex-based hook command - Implements Command::parse() -.
enum CommandResult	parse_folder_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse folder hook command - Implements Command::parse() -.
enum CommandResult	parse_crypt_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse crypt hook commands - Implements Command::parse() -.
enum CommandResult	parse_mbox_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse mbox hook command - Implements Command::parse() -.
enum CommandResult	parse_compress_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse compress hook commands - Implements Command::parse() -.
enum CommandResult	parse_index_hook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the index format hook command - Implements Command::parse() -.
enum CommandResult	parse_unhook (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the unhook command - Implements Command::parse() -.
enum CommandResult	parse_subscribe_to (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'subscribe-to' command - Implements Command::parse() -.
enum CommandResult	parse_unsubscribe_from (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unsubscribe-from' command - Implements Command::parse() -.
enum CommandResult	parse_subjectrx_list (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'subject-regex' command - Implements Command::parse() -.
enum CommandResult	parse_unsubjectrx_list (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unsubject-regex' command - Implements Command::parse() -.
enum CommandResult	parse_dump (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse 'bind' and 'macro' commands - Implements Command::parse() -.
enum CommandResult	parse_push (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'push' command - Implements Command::parse() -.
enum CommandResult	parse_bind (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'bind' command - Implements Command::parse() -.
enum CommandResult	parse_unbind (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unbind' and 'unmacro' commands - Implements Command::parse() -.
enum CommandResult	parse_macro (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'macro' command - Implements Command::parse() -.
enum CommandResult	parse_exec (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'exec' command - Implements Command::parse() -.
enum CommandResult	parse_lua (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'lua' command - Implements Command::parse() -.
enum CommandResult	parse_lua_source (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'lua-source' command - Implements Command::parse() -.
enum CommandResult	parse_set (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'set' family of commands - Implements Command::parse() -.
enum CommandResult	parse_my_header (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'my-header' command - Implements Command::parse() -.
enum CommandResult	parse_unmy_header (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unmy-header' command - Implements Command::parse() -.
enum CommandResult	parse_sidebar_pin (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'sidebar-pin' command - Implements Command::parse() -.
enum CommandResult	parse_sidebar_unpin (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'sidebar-unpin' command - Implements Command::parse() -.

Detailed Description

Function to parse a command.

Parameters

cmd	Command being parsed
line	Buffer containing string to be parsed
pc	Parse Context
pe	Parse Errors

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Precondition

cmd is not NULL

line is not NULL

pc is not NULL

pe is not NULL

Function Documentation

parse_alternates()

enum CommandResult parse_alternates	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'alternates' command - Implements Command::parse() -.

Parse:

• alternates [ -group <name> ... ] <regex> [ <regex> ... ]

Definition at line 68 of file alternates.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, token, line, err, mod_data->groups) == -1)
      goto done;
 
    mutt_regexlist_remove(&mod_data->unalternates, buf_string(token));
 
    if (mutt_regexlist_add(&mod_data->alternates, 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));
 
  mutt_debug(LL_NOTIFY, "NT_ALTERN_ADD: %s\n", buf_string(token));
  notify_send(mod_data->alternates_notify, NT_ALTERN, NT_ALTERN_ADD, NULL);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  grouplist_destroy(&gl);
  return rc;
}

Here is the call graph for this function:

parse_unalternates()

enum CommandResult parse_unalternates	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unalternates' command - Implements Command::parse() -.

Parse:

• unalternates { * | <regex> ... }

Definition at line 119 of file alternates.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&mod_data->alternates, buf_string(token));
 
    if (!mutt_str_equal(buf_string(token), "*") &&
        (mutt_regexlist_add(&mod_data->unalternates, buf_string(token), REG_ICASE, err) != 0))
    {
      goto done;
    }
 
  } while (MoreArgs(line));
 
  mutt_debug(LL_NOTIFY, "NT_ALTERN_DELETE: %s\n", buf_string(token));
  notify_send(mod_data->alternates_notify, NT_ALTERN, NT_ALTERN_DELETE, NULL);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_alias()

enum CommandResult parse_alias	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'alias' command - Implements Command::parse() -.

e.g. "alias jim James Smith <js@example.com> # Pointy-haired boss"

Parse:

• alias [ -group <name> ... ] <key> <address> [, <address> ...] [ # [ <comments> ] [ tags:... ]]

Definition at line 178 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  struct Alias *a = NULL;
  enum NotifyAlias event;
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  /* name */
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
  mutt_debug(LL_DEBUG5, "First token is '%s'\n", buf_string(token));
  if (parse_grouplist(&gl, token, line, err, mod_data->groups) == -1)
    goto done;
 
  char *name = mutt_str_dup(buf_string(token));
 
  /* address list */
  parse_extract_token(token, line, TOKEN_QUOTE | TOKEN_SPACE | TOKEN_SEMICOLON);
  mutt_debug(LL_DEBUG5, "Second token is '%s'\n", buf_string(token));
  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
  int parsed = mutt_addrlist_parse2(&al, buf_string(token));
  if (parsed == 0)
  {
    buf_printf(err, _("Warning: Bad address '%s' in alias '%s'"), buf_string(token), name);
    FREE(&name);
    goto done;
  }
 
  /* IDN */
  char *estr = NULL;
  if (mutt_addrlist_to_intl(&al, &estr))
  {
    buf_printf(err, _("Warning: Bad IDN '%s' in alias '%s'"), estr, name);
    FREE(&name);
    FREE(&estr);
    goto done;
  }
 
  /* check to see if an alias with this name already exists */
  struct Alias **ap = NULL;
  ARRAY_FOREACH(ap, &mod_data->aliases)
  {
    if (mutt_istr_equal((*ap)->name, name))
    {
      a = *ap;
      break;
    }
  }
 
  if (a)
  {
    FREE(&name);
    alias_reverse_delete(a);
    /* override the previous value */
    mutt_addrlist_clear(&a->addr);
    FREE(&a->comment);
    event = NT_ALIAS_CHANGE;
  }
  else
  {
    /* create a new alias */
    a = alias_new();
    a->name = name;
    ARRAY_ADD(&mod_data->aliases, a);
    event = NT_ALIAS_ADD;
  }
  a->addr = al;
 
  grouplist_add_addrlist(&gl, &a->addr);
 
  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  if (c_debug_level > LL_DEBUG4)
  {
    /* A group is terminated with an empty address, so check addr->mailbox */
    struct Address *addr = NULL;
    TAILQ_FOREACH(addr, &a->addr, entries)
    {
      if (!addr->mailbox)
        break;
 
      if (addr->group)
        mutt_debug(LL_DEBUG5, "  Group %s\n", buf_string(addr->mailbox));
      else
        mutt_debug(LL_DEBUG5, "  %s\n", buf_string(addr->mailbox));
    }
  }
 
  if (!MoreArgs(line) && (line->dptr[0] == '#'))
  {
    line->dptr++; // skip over the "# "
    if (*line->dptr == ' ')
      line->dptr++;
 
    parse_alias_comments(a, line->dptr);
    *line->dptr = '\0'; // We're done parsing
  }
 
  alias_reverse_add(a);
 
  mutt_debug(LL_NOTIFY, "%s: %s\n",
             (event == NT_ALIAS_ADD) ? "NT_ALIAS_ADD" : "NT_ALIAS_CHANGE", a->name);
  struct EventAlias ev_a = { a };
  notify_send(NeoMutt->notify, NT_ALIAS, event, &ev_a);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  grouplist_destroy(&gl);
  return rc;
}

Here is the call graph for this function:

parse_unalias()

enum CommandResult parse_unalias	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unalias' command - Implements Command::parse() -.

Parse:

• unalias { * | <key> ... }

Definition at line 308 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    struct Alias **ap = NULL;
    if (mutt_str_equal("*", buf_string(token)))
    {
      ARRAY_FOREACH(ap, &mod_data->aliases)
      {
        alias_reverse_delete(*ap);
      }
 
      aliaslist_clear(&mod_data->aliases);
      goto done;
    }
 
    ARRAY_FOREACH(ap, &mod_data->aliases)
    {
      if (!mutt_istr_equal(buf_string(token), (*ap)->name))
        continue;
 
      struct Alias *a = *ap;
      ARRAY_REMOVE(&mod_data->aliases, ap);
      alias_reverse_delete(a);
      alias_free(&a);
      break;
    }
  } while (MoreArgs(line));
 
done:
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_group()

enum CommandResult parse_group	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'group' and 'ungroup' commands - Implements Command::parse() -.

Parse:

• group [ -group <name> ... ] { -rx <regex> ... | -addr <address> ... }
• ungroup [ -group <name> ... ] { * | -rx <regex> ... | -addr <address> ... }

Definition at line 90 of file group.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  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, mod_data->groups) == -1)
      goto done;
 
    if ((cmd->id == CMD_UNGROUP) && mutt_istr_equal(buf_string(token), "*"))
    {
      groups_remove_grouplist(mod_data->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->id == CMD_GROUP) &&
              (grouplist_add_regex(&gl, buf_string(token), REG_ICASE, err) != 0))
          {
            goto done;
          }
          else if ((cmd->id == CMD_UNGROUP) &&
                   (groups_remove_regex(mod_data->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->id == CMD_GROUP)
            grouplist_add_addrlist(&gl, &al);
          else if (cmd->id == CMD_UNGROUP)
            groups_remove_addrlist(mod_data->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;
}

Here is the call graph for this function:

parse_lists()

enum CommandResult parse_lists	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'lists' command - Implements Command::parse() -.

Parse:

• lists [ -group <name> ... ] <regex> [ <regex> ... ]

Definition at line 191 of file group.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, token, line, err, mod_data->groups) == -1)
      goto done;
 
    mutt_regexlist_remove(&mod_data->unmail, buf_string(token));
 
    if (mutt_regexlist_add(&mod_data->mail, 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;
}

Here is the call graph for this function:

parse_subscribe()

enum CommandResult parse_subscribe	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'subscribe' command - Implements Command::parse() -.

Parse:

• subscribe [ -group <name> ... ] <regex> [ <regex> ... ]

Definition at line 239 of file group.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, token, line, err, mod_data->groups) == -1)
      goto done;
 
    mutt_regexlist_remove(&mod_data->unmail, buf_string(token));
    mutt_regexlist_remove(&mod_data->unsubscribed, buf_string(token));
 
    if (mutt_regexlist_add(&mod_data->mail, buf_string(token), REG_ICASE, err) != 0)
      goto done;
 
    if (mutt_regexlist_add(&mod_data->subscribed, 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;
}

Here is the call graph for this function:

parse_unlists()

enum CommandResult parse_unlists	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unlists' command - Implements Command::parse() -.

Parse:

• unlists { * | <regex> ... }

Definition at line 291 of file group.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  mutt_hash_free(&mod_data->auto_subscribe_cache);
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&mod_data->subscribed, buf_string(token));
    mutt_regexlist_remove(&mod_data->mail, buf_string(token));
 
    if (!mutt_str_equal(buf_string(token), "*") &&
        (mutt_regexlist_add(&mod_data->unmail, buf_string(token), REG_ICASE, err) != 0))
    {
      goto done;
    }
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_unsubscribe()

enum CommandResult parse_unsubscribe	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unsubscribe' command - Implements Command::parse() -.

Parse:

• unsubscribe { * | <regex> ... }

Definition at line 335 of file group.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct AliasModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ALIAS);
  ASSERT(mod_data);
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  mutt_hash_free(&mod_data->auto_subscribe_cache);
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&mod_data->subscribed, buf_string(token));
 
    if (!mutt_str_equal(buf_string(token), "*") &&
        (mutt_regexlist_add(&mod_data->unsubscribed, buf_string(token), REG_ICASE, err) != 0))
    {
      goto done;
    }
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_attachments()

enum CommandResult parse_attachments	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'attachments' command - Implements Command::parse() -.

Parse:

• attachments { + | - }<disposition> <mime-type> [ <mime-type> ...]
• attachments ?

Definition at line 472 of file commands.c.

{
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  struct Buffer *err = pe->message;
 
  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;
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
  char *category = token->data;
  char op = *category++;
 
  if (op == '?')
  {
    mutt_endwin();
    fflush(stdout);
    printf("\n%s\n\n", _("Current attachments settings:"));
    print_attach_list(&mod_data->attach_allow, '+', "A");
    print_attach_list(&mod_data->attach_exclude, '-', "A");
    print_attach_list(&mod_data->inline_allow, '+', "I");
    print_attach_list(&mod_data->inline_exclude, '-', "I");
    mutt_any_key_to_continue(NULL);
 
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  if ((op != '+') && (op != '-'))
  {
    op = '+';
    category--;
  }
 
  struct ListHead *head = NULL;
  if (mutt_istr_startswith("attachment", category))
  {
    if (op == '+')
      head = &mod_data->attach_allow;
    else
      head = &mod_data->attach_exclude;
  }
  else if (mutt_istr_startswith("inline", category))
  {
    if (op == '+')
      head = &mod_data->inline_allow;
    else
      head = &mod_data->inline_exclude;
  }
  else
  {
    buf_strcpy(err, _("attachments: invalid disposition"));
    goto done;
  }
 
  rc = parse_attach_list(cmd, line, head, err);
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_unattachments()

enum CommandResult parse_unattachments	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unattachments' command - Implements Command::parse() -.

Parse:

• unattachments { + | - } disposition mime-type [ mime-type ...]
• unattachments *

Definition at line 550 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  char op;
  const char *p = NULL;
  struct ListHead *head = NULL;
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
  p = buf_string(token);
  op = *p++;
 
  if (op == '*')
  {
    mutt_list_free_type(&mod_data->attach_allow, (list_free_t) attachmatch_free);
    mutt_list_free_type(&mod_data->attach_exclude, (list_free_t) attachmatch_free);
    mutt_list_free_type(&mod_data->inline_allow, (list_free_t) attachmatch_free);
    mutt_list_free_type(&mod_data->inline_exclude, (list_free_t) attachmatch_free);
 
    mutt_debug(LL_NOTIFY, "NT_ATTACH_DELETE_ALL\n");
    notify_send(mod_data->attachments_notify, NT_ATTACH, NT_ATTACH_DELETE_ALL, NULL);
 
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  if ((op != '+') && (op != '-'))
  {
    op = '+';
    p--;
  }
  if (mutt_istr_startswith("attachment", p))
  {
    if (op == '+')
      head = &mod_data->attach_allow;
    else
      head = &mod_data->attach_exclude;
  }
  else if (mutt_istr_startswith("inline", p))
  {
    if (op == '+')
      head = &mod_data->inline_allow;
    else
      head = &mod_data->inline_exclude;
  }
  else
  {
    buf_strcpy(err, _("unattachments: invalid disposition"));
    goto done;
  }
 
  rc = parse_unattach_list(cmd, line, head, err);
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_mime_lookup()

enum CommandResult parse_mime_lookup	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'mime-lookup' command - Implements Command::parse() -.

Parse:

• mime-lookup { + | - }<disposition> <mime-type> [ <mime-type> ...]
• mime-lookup ?

Definition at line 652 of file commands.c.

{
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  return parse_stailq(cmd, line, &mod_data->mime_lookup, pc, pe);
}

Here is the call graph for this function:

parse_unmime_lookup()

enum CommandResult parse_unmime_lookup	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unmime-lookup' command - Implements Command::parse() -.

Parse:

• unmime-lookup { + | - } disposition mime-type [ mime-type ...]
• unmime-lookup *

Definition at line 668 of file commands.c.

{
  struct AttachModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_ATTACH);
  ASSERT(mod_data);
 
  return parse_unstailq(cmd, line, &mod_data->mime_lookup, pc, pe);
}

Here is the call graph for this function:

parse_uncolor_command()

enum CommandResult parse_uncolor_command	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse an 'uncolor' command - Implements Command::parse() -.

Usage:

• uncolor OBJECT [ PATTERN | REGEX | * ]

Definition at line 200 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  // Peek at the next token ('*' won't match a colour name)
  if (line->dptr[0] == '*')
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    if (mutt_str_equal(buf_string(token), "*"))
    {
      colors_reset();
      rc = MUTT_CMD_SUCCESS;
      goto done;
    }
  }
 
  enum ColorId cid = MT_COLOR_NONE;
  color_debug(LL_DEBUG5, "uncolor: %s\n", buf_string(token));
  rc = parse_object(cmd, line, &cid, err);
  if (rc != MUTT_CMD_SUCCESS)
    goto done;
 
  if ((cid == MT_COLOR_STATUS) && !MoreArgs(line))
  {
    color_debug(LL_DEBUG5, "simple\n");
    simple_color_reset(cid); // default colour for the status bar
    goto done;
  }
 
  if (!mutt_color_has_pattern(cid))
  {
    color_debug(LL_DEBUG5, "simple\n");
    simple_color_reset(cid);
    goto done;
  }
 
  if (!MoreArgs(line))
  {
    if (regex_colors_parse_uncolor(cid, NULL))
      rc = MUTT_CMD_SUCCESS;
    else
      rc = MUTT_CMD_ERROR;
    goto done;
  }
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf_string(token)))
    {
      if (regex_colors_parse_uncolor(cid, NULL))
        rc = MUTT_CMD_SUCCESS;
      else
        rc = MUTT_CMD_ERROR;
      goto done;
    }
 
    regex_colors_parse_uncolor(cid, buf_string(token));
 
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_uncolor()

enum CommandResult parse_uncolor	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'uncolor' command - Implements Command::parse() -.

Parse:

• uncolor <object> { * | <pattern> ... }

Definition at line 447 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  if (!OptGui) // No GUI, so quietly discard the command
  {
    while (MoreArgs(line))
    {
      parse_extract_token(token, line, TOKEN_NO_FLAGS);
    }
    goto done;
  }
 
  color_debug(LL_DEBUG5, "parse: %s\n", buf_string(token));
  rc = parse_uncolor_command(cmd, line, pc, pe);
  curses_colors_dump(token);
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_unmono()

enum CommandResult parse_unmono	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unmono' command - Implements Command::parse() -.

Parse:

• unmono <object> { * | <pattern> ... }

Definition at line 485 of file commands.c.

{
  // Quietly discard the command
  struct Buffer *token = buf_pool_get();
  while (MoreArgs(line))
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
  }
  buf_pool_release(&token);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_color()

enum CommandResult parse_color	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'color' command - Implements Command::parse() -.

Parse:

• color object [ attribute ...] foreground background
• color index [ attribute ...] foreground background [ pattern ]
• color { header | body } [ attribute ...] foreground background regex

Definition at line 507 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_SUCCESS;
 
  // No GUI, or no colours, so quietly discard the command
  if (!OptGui || (COLORS == 0))
  {
    while (MoreArgs(line))
    {
      parse_extract_token(token, line, TOKEN_NO_FLAGS);
    }
    goto done;
  }
 
  color_debug(LL_DEBUG5, "parse: color\n");
  rc = parse_color_command(cmd, line, err, parse_color_pair);
  curses_colors_dump(token);
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_mono()

enum CommandResult parse_mono	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'mono' command - Implements Command::parse() -.

Parse:

• mono <object> <attribute> [ <pattern> | <regex> ]

Definition at line 540 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_SUCCESS;
 
  // No GUI, or colours available, so quietly discard the command
  if (!OptGui || (COLORS != 0))
  {
    while (MoreArgs(line))
    {
      parse_extract_token(token, line, TOKEN_NO_FLAGS);
    }
    goto done;
  }
 
  color_debug(LL_DEBUG5, "parse: %s\n", buf_string(token));
  rc = parse_color_command(cmd, line, err, parse_attr_spec);
  curses_colors_dump(token);
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_ifdef()

enum CommandResult parse_ifdef	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'ifdef' and 'ifndef' commands - Implements Command::parse() -.

The 'ifdef' command allows conditional elements in the config file. If a given variable, function, command or compile-time symbol exists, then read the rest of the line of config commands. e.g. ifdef sidebar source ~/.neomutt/sidebar.rc

Parse:

• ‘ifdef <symbol> ’<config-command> [ <args> ... ]' -ifndef <symbol> '<config-command> [ <args> ... ]'`

Definition at line 89 of file ifdef.c.

{
  struct Buffer *err = pe->message;
 
  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->id == CMD_IFDEF)) || (!res && (cmd->id == CMD_IFNDEF)))
  {
    // Cheat: Remove the `const` so we can recurse
    rc = parse_rc_line(token, (struct ParseContext *) pc, pe);
    if (rc == MUTT_CMD_ERROR)
      mutt_error(_("Error: %s"), buf_string(err));
 
    goto done;
  }
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_finish()

enum CommandResult parse_finish	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'finish' command - Implements Command::parse() -.

Return values

MUTT_CMD_FINISH	Stop processing the current file
MUTT_CMD_WARNING	Failed

If the 'finish' command is found, we should stop reading the current file.

Parse:

• finish

Definition at line 150 of file ifdef.c.

{
  struct Buffer *err = pe->message;
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  return MUTT_CMD_FINISH;
}

Here is the call graph for this function:

parse_mailboxes()

enum CommandResult parse_mailboxes	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'mailboxes' command - Implements Command::parse() -.

Parse:

• mailboxes [[ -label <label> ] | -nolabel ] [[ -notify | -nonotify ] [ -poll | -nopoll ] <mailbox> ] [ ... ]
• named-mailboxes <description> <mailbox> [ <description> <mailbox> ... ]

Definition at line 349 of file mailboxes.c.

{
  struct Buffer *err = pe->message;
 
  struct ParseMailboxArray args = ARRAY_HEAD_INITIALIZER;
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  if (!parse_mailboxes_args(cmd, line, err, &args))
    goto done;
 
  rc = parse_mailboxes_exec(cmd, &args, err);
 
done:
  parse_mailbox_array_free(&args);
  return rc;
}

Here is the call graph for this function:

parse_unmailboxes()

enum CommandResult parse_unmailboxes	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unmailboxes' command - Implements Command::parse() -.

Parse:

• unmailboxes { * | <mailbox> ... }

Definition at line 440 of file mailboxes.c.

{
  struct Buffer *err = pe->message;
 
  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;
    }
 
    expand_path(token, false);
 
    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;
}

Here is the call graph for this function:

parse_cd()

enum CommandResult parse_cd	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'cd' command - Implements Command::parse() -.

Parse:

• cd [ <directory> ]

Definition at line 59 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  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
  {
    expand_path(token, false);
  }
 
  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;
}

Here is the call graph for this function:

parse_echo()

enum CommandResult parse_echo	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'echo' command - Implements Command::parse() -.

Parse:

• echo <message>

Definition at line 96 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  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;
}

Here is the call graph for this function:

parse_version()

enum CommandResult parse_version	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'version' command - Implements Command::parse() -.

Parse:

• version

Definition at line 125 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  // 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;
}

Here is the call graph for this function:

parse_setenv()

enum CommandResult parse_setenv	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'setenv' and 'unsetenv' commands - Implements Command::parse() -.

Parse:

• setenv { <variable>? | <variable>=<value> }
• unsetenv <variable>

Note: Also accepts the old syntax: setenv <variable> <value>

Definition at line 67 of file setenv.c.

{
  struct Buffer *err = pe->message;
 
  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->id == CMD_UNSETENV);
 
  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);
 
  /* Validate variable name: must match [_a-zA-Z][_a-zA-Z0-9]* */
  const char *name = buf_string(token);
  if (!buf_is_empty(token))
  {
    /* First character must be a letter or underscore */
    if (!isalpha(name[0]) && (name[0] != '_'))
    {
      buf_printf(err, _("%s: invalid variable name '%s'"), cmd->name, name);
      goto done;
    }
    /* Subsequent characters must be letter, digit, or underscore */
    for (size_t i = 1; name[i] != '\0'; i++)
    {
      if (!isalpha(name[i]) && !mutt_isdigit(name[i]) && (name[i] != '_'))
      {
        buf_printf(err, _("%s: invalid variable name '%s'"), cmd->name, name);
        goto done;
      }
    }
  }
 
  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)
  {
    envlist_unset(&NeoMutt->env, buf_string(token));
    rc = MUTT_CMD_SUCCESS;
    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;
}

Here is the call graph for this function:

parse_source()

enum CommandResult parse_source	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'source' command - Implements Command::parse() -.

Parse:

• source <filename> [ <filename> ... ]

Definition at line 227 of file source.c.

{
  struct Buffer *err = pe->message;
 
  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);
    expand_path(path, false);
 
    // Cheat: Remove the `const` so we can recurse
    if (source_rc(buf_string(path), (struct ParseContext *) pc, pe) < 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;
}

Here is the call graph for this function:

parse_stailq()

enum CommandResult parse_stailq	(	const struct Command *	cmd,
		struct Buffer *	line,
		struct ListHead *	list,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse a list command - Implements Command::parse() -.

Parameters

cmd	Command being parsed
line	Buffer containing string to be parsed
list	List for the results
pc	Parse Context
pe	Parse Errors

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 52 of file stailq.c.

{
  struct Buffer *err = pe->message;
 
  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(list, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_unstailq()

enum CommandResult parse_unstailq	(	const struct Command *	cmd,
		struct Buffer *	line,
		struct ListHead *	list,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse an unlist command - Implements Command::parse() -.

Parameters

cmd	Command being parsed
line	Buffer containing string to be parsed
list	List for the results
pc	Parse Context
pe	Parse Errors

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 85 of file stailq.c.

{
  struct Buffer *err = pe->message;
 
  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(list);
      break;
    }
    remove_from_stailq(list, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_list()

enum CommandResult parse_list	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse a list command - Implements Command::parse() -.

Parse:

• alternative-order <mime-type>[/<mime-subtype> ] [ <mime-type>[/<mime-subtype> ] ... ]
• auto-view <mime-type>[/<mime-subtype> ] [ <mime-type>[/<mime-subtype> ] ... ]
• header-order <header> [ <header> ... ]
• mailto-allow { * | <header-field> ... }

Definition at line 50 of file commands.c.

{
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  switch (cmd->id)
  {
    case CMD_ALTERNATIVE_ORDER:
      return parse_stailq(cmd, line, &mod_data->alternative_order, pc, pe);
 
    case CMD_AUTO_VIEW:
      return parse_stailq(cmd, line, &mod_data->auto_view, pc, pe);
 
    case CMD_HEADER_ORDER:
      return parse_stailq(cmd, line, &mod_data->header_order, pc, pe);
 
    case CMD_MAILTO_ALLOW:
      return parse_stailq(cmd, line, &mod_data->mail_to_allow, pc, pe);
 
    default:
      ASSERT(false);
  }
 
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_unlist()

enum CommandResult parse_unlist	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse an unlist command - Implements Command::parse() -.

Parse:

• unalternative-order { * | [ <mime-type>[/<mime-subtype> ] ... ] }
• unauto-view { * | [ <mime-type>[/<mime-subtype> ] ... ] }
• unheader-order { * | <header> ... }
• unmailto-allow { * | <header-field> ... }

Definition at line 86 of file commands.c.

{
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  switch (cmd->id)
  {
    case CMD_UNALTERNATIVE_ORDER:
      return parse_unstailq(cmd, line, &mod_data->alternative_order, pc, pe);
 
    case CMD_UNAUTO_VIEW:
      return parse_unstailq(cmd, line, &mod_data->auto_view, pc, pe);
 
    case CMD_UNHEADER_ORDER:
      return parse_unstailq(cmd, line, &mod_data->header_order, pc, pe);
 
    case CMD_UNMAILTO_ALLOW:
      return parse_unstailq(cmd, line, &mod_data->mail_to_allow, pc, pe);
 
    default:
      ASSERT(false);
  }
 
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_tag_formats()

enum CommandResult parse_tag_formats	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'tag-formats' command - Implements Command::parse() -.

Parse config like: tag-formats pgp GP

Note

This maps format -> tag

Parse:

• tag-formats <tag> <format-string> [ <tag> <format-string> ... ] }

Definition at line 123 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  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();
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  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(mod_data->tag_formats, buf_string(fmt));
    if (tmp)
    {
      mutt_warning(_("tag format '%s' already registered as '%s'"), buf_string(fmt), tmp);
      continue;
    }
 
    mutt_hash_insert(mod_data->tag_formats, buf_string(fmt), buf_strdup(tag));
  }
 
  buf_pool_release(&tag);
  buf_pool_release(&fmt);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_tag_transforms()

enum CommandResult parse_tag_transforms	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'tag-transforms' command - Implements Command::parse() -.

Parse config like: tag-transforms pgp P

Note

This maps tag -> transform

Parse:

• tag-transforms <tag> <transformed-string> [ <tag> <transformed-string> ... ]}

Definition at line 174 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *tag = buf_pool_get();
  struct Buffer *trans = buf_pool_get();
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  while (MoreArgs(line))
  {
    parse_extract_token(tag, line, TOKEN_NO_FLAGS);
    if (buf_is_empty(tag))
      continue;
 
    parse_extract_token(trans, line, TOKEN_NO_FLAGS);
    const char *trn = buf_string(trans);
 
    /* avoid duplicates */
    const char *tmp = mutt_hash_find(mod_data->tag_transforms, buf_string(tag));
    if (tmp)
    {
      mutt_warning(_("tag transform '%s' already registered as '%s'"),
                   buf_string(tag), tmp);
      continue;
    }
 
    mutt_hash_insert(mod_data->tag_transforms, buf_string(tag), mutt_str_dup(trn));
  }
 
  buf_pool_release(&tag);
  buf_pool_release(&trans);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_ignore()

enum CommandResult parse_ignore	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'ignore' command - Implements Command::parse() -.

Parse:

• ignore <string> [ <string> ...]

Definition at line 50 of file ignore.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    remove_from_stailq(&mod_data->unignore, buf_string(token));
    add_to_stailq(&mod_data->ignore, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unignore()

enum CommandResult parse_unignore	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unignore' command - Implements Command::parse() -.

Parse:

• unignore { * | <string> ... }

Definition at line 83 of file ignore.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  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(&mod_data->unignore, buf_string(token));
 
    remove_from_stailq(&mod_data->ignore, buf_string(token));
  } while (MoreArgs(line));
 
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_score()

enum CommandResult parse_score	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'score' command - Implements Command::parse() -.

Parse:

• score <pattern> <value>

Definition at line 76 of file score.c.

{
  struct Buffer *err = pe->message;
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Score *ptr = NULL, *last = NULL;
  char *pattern = NULL, *patchar = NULL;
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    goto done;
  }
  pattern = buf_strdup(token);
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  /* look for an existing entry and update the value, else add it to the end
   * of the list */
  for (ptr = mod_data->score_list, last = NULL; ptr; last = ptr, ptr = ptr->next)
    if (mutt_str_equal(pattern, ptr->str))
      break;
 
  if (ptr)
  {
    /* 'token' arg was cleared and 'pattern' holds the only reference;
     * as here 'ptr' != NULL -> update the value only in which case
     * ptr->str already has the string, so pattern should be freed.  */
    FREE(&pattern);
  }
  else
  {
    struct MailboxView *mv_cur = get_current_mailbox_view();
    struct PatternList *pat = mutt_pattern_comp(mv_cur, pattern, MUTT_PC_NO_FLAGS, err);
    if (!pat)
    {
      goto done;
    }
    ptr = MUTT_MEM_CALLOC(1, struct Score);
    if (last)
      last->next = ptr;
    else
      mod_data->score_list = ptr;
    ptr->pat = pat;
    ptr->str = pattern;
    pattern = NULL;
  }
 
  patchar = token->data;
  if (*patchar == '=')
  {
    ptr->exact = true;
    patchar++;
  }
 
  if (!mutt_str_atoi_full(patchar, &ptr->val))
  {
    buf_strcpy(err, _("Error: score: invalid number"));
    goto done;
  }
  OptNeedRescore = true;
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  FREE(&pattern);
  return rc;
}

Here is the call graph for this function:

parse_unscore()

enum CommandResult parse_unscore	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unscore' command - Implements Command::parse() -.

Parse:

• unscore { * | <pattern> ... }

Definition at line 166 of file score.c.

{
  struct Buffer *err = pe->message;
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Score *tmp = NULL, *last = NULL;
  struct Buffer *token = buf_pool_get();
 
  while (MoreArgs(line))
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf_string(token)))
    {
      score_list_free(&mod_data->score_list);
    }
    else
    {
      for (tmp = mod_data->score_list; tmp; last = tmp, tmp = tmp->next)
      {
        if (mutt_str_equal(buf_string(token), tmp->str))
        {
          if (last)
            last->next = tmp->next;
          else
            mod_data->score_list = tmp->next;
          mutt_pattern_free(&tmp->pat);
          FREE(&tmp);
          /* there should only be one score per pattern, so we can stop here */
          break;
        }
      }
    }
  }
 
  OptNeedRescore = true;
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_nospam()

enum CommandResult parse_nospam	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'nospam' command - Implements Command::parse() -.

Parse:

• nospam { * | <regex> }

Definition at line 51 of file spam.c.

{
  struct Buffer *err = pe->message;
 
  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;
  }
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  // "*" is special - clear both spam and nospam lists
  if (mutt_str_equal(buf_string(token), "*"))
  {
    mutt_replacelist_free(&mod_data->spam);
    mutt_regexlist_free(&mod_data->no_spam);
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  // If it's on the spam list, just remove it
  if (mutt_replacelist_remove(&mod_data->spam, buf_string(token)) != 0)
  {
    rc = MUTT_CMD_SUCCESS;
    goto done;
  }
 
  // Otherwise, add it to the nospam list
  if (mutt_regexlist_add(&mod_data->no_spam, buf_string(token), REG_ICASE, err) != 0)
  {
    rc = MUTT_CMD_ERROR;
    goto done;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_spam()

enum CommandResult parse_spam	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'spam' command - Implements Command::parse() -.

Parse:

• spam <regex> [ <format> ]

Definition at line 113 of file spam.c.

{
  struct Buffer *err = pe->message;
 
  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);
 
  struct EmailModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_EMAIL);
  ASSERT(mod_data);
 
  // 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(&mod_data->spam, buf_string(token), buf_string(templ), err) != 0)
      goto done;
  }
  else
  {
    // If not, try to remove from the nospam list
    mutt_regexlist_remove(&mod_data->no_spam, buf_string(token));
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&templ);
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_hooks()

enum CommandResult parse_hooks	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'hooks' command - Implements Command::parse() -.

Parse:

• hooks

Definition at line 227 of file dump.c.

{
  struct Buffer *err = pe->message;
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  if (!StartupComplete)
    return MUTT_CMD_SUCCESS;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  if (TAILQ_EMPTY(&mod_data->hooks))
  {
    buf_printf(err, _("%s: No Hooks are configured"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *tempfile = buf_pool_get();
  buf_mktemp(tempfile);
 
  FILE *fp = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp)
  {
    mutt_error(_("Could not create temporary file %s"), buf_string(tempfile));
    buf_pool_release(&tempfile);
    return MUTT_CMD_ERROR;
  }
 
  struct Buffer *buf = buf_pool_get();
 
  hooks_dump_simple(buf);
  hooks_dump_index(buf);
  hooks_dump_charset(buf);
 
  mutt_file_save_str(fp, buf_string(buf));
  mutt_file_fclose(&fp);
  buf_pool_release(&buf);
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pdata.fname = buf_string(tempfile);
 
  pview.banner = "hooks";
  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:

parse_charset_hook()

enum CommandResult parse_charset_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse charset Hook commands - Implements Command::parse() -.

Parse:

• charset-hook <alias> <charset>
• iconv-hook <charset> <local-charset>

Definition at line 56 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *alias = buf_pool_get();
  struct Buffer *charset = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  if (parse_extract_token(alias, line, TOKEN_NO_FLAGS) < 0)
    goto done;
  if (parse_extract_token(charset, line, TOKEN_NO_FLAGS) < 0)
    goto done;
 
  const enum LookupType type = (cmd->id == CMD_ICONV_HOOK) ? MUTT_LOOKUP_ICONV :
                                                             MUTT_LOOKUP_CHARSET;
 
  if (buf_is_empty(alias) || buf_is_empty(charset))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
  }
  else if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    buf_reset(line); // clean up buffer to avoid a mess with further rcfile processing
    rc = MUTT_CMD_WARNING;
  }
  else if (mutt_ch_lookup_add(type, buf_string(alias), buf_string(charset), err))
  {
    rc = MUTT_CMD_SUCCESS;
  }
 
done:
  buf_pool_release(&alias);
  buf_pool_release(&charset);
 
  return rc;
}

Here is the call graph for this function:

parse_global_hook()

enum CommandResult parse_global_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse global Hook commands - Implements Command::parse() -.

Parse:

• shutdown-hook <command>
• startup-hook <command>
• timeout-hook <command>

Definition at line 110 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  struct Buffer *command = buf_pool_get();
 
  // TOKEN_SPACE allows the command to contain whitespace, without quoting
  parse_extract_token(command, line, TOKEN_SPACE);
 
  if (buf_is_empty(command))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  /* check to make sure that a matching Hook doesn't already exist */
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    /* Ignore duplicate global Hooks */
    if ((hook->id == cmd->id) && mutt_str_equal(hook->command, buf_string(command)))
    {
      rc = MUTT_CMD_SUCCESS;
      goto cleanup;
    }
  }
 
  hook = hook_new();
  hook->id = cmd->id;
  hook->command = buf_strdup(command);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = NULL;
  hook->regex.pattern = NULL;
  hook->regex.regex = NULL;
  hook->regex.pat_not = false;
  hook->expando = NULL;
 
  TAILQ_INSERT_TAIL(&mod_data->hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&command);
  return rc;
}

Here is the call graph for this function:

parse_pattern_hook()

enum CommandResult parse_pattern_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse pattern-based Hook commands - Implements Command::parse() -.

Parse:

• message-hook <pattern> <command>
• reply-hook <pattern> <command>
• send-hook <pattern> <command>
• send2-hook <pattern> <command>

Definition at line 176 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  struct PatternList *pat = NULL;
 
  struct Buffer *command = buf_pool_get();
  struct Buffer *pattern = buf_pool_get();
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
 
  parse_extract_token(pattern, line, TOKEN_NO_FLAGS);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  // TOKEN_SPACE allows the command to contain whitespace, without quoting
  parse_extract_token(command, line, TOKEN_SPACE);
 
  if (buf_is_empty(command))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  const char *const c_default_hook = cs_subset_string(NeoMutt->sub, "default_hook");
  if (c_default_hook)
  {
    mutt_check_simple(pattern, c_default_hook);
  }
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if ((hook->id == cmd->id) && (hook->regex.pat_not == pat_not) &&
        mutt_str_equal(buf_string(pattern), hook->regex.pattern))
    {
      /* these hooks allow multiple commands with the same pattern,
       * so if we've already seen this pattern/command pair,
       * just ignore it instead of creating a duplicate */
      if (mutt_str_equal(hook->command, buf_string(command)))
      {
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
  }
 
  PatternCompFlags comp_flags;
  if (cmd->id == CMD_SEND2_HOOK)
    comp_flags = MUTT_PC_SEND_MODE_SEARCH;
  else if (cmd->id == CMD_SEND_HOOK)
    comp_flags = MUTT_PC_NO_FLAGS;
  else
    comp_flags = MUTT_PC_FULL_MSG;
 
  struct MailboxView *mv_cur = get_current_mailbox_view();
  pat = mutt_pattern_comp(mv_cur, buf_string(pattern), comp_flags, err);
  if (!pat)
    goto cleanup;
 
  hook = hook_new();
  hook->id = cmd->id;
  hook->command = buf_strdup(command);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = pat;
  hook->regex.pattern = buf_strdup(pattern);
  hook->regex.regex = NULL;
  hook->regex.pat_not = pat_not;
  hook->expando = NULL;
 
  TAILQ_INSERT_TAIL(&mod_data->hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&command);
  buf_pool_release(&pattern);
  return rc;
}

Here is the call graph for this function:

parse_mailbox_hook()

enum CommandResult parse_mailbox_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse mailbox pattern hook commands - Implements Command::parse() -.

Parse:

• fcc-hook <pattern> <mailbox>
• fcc-save-hook <pattern> <mailbox>
• save-hook <pattern> <mailbox>

Definition at line 348 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
 
  struct Buffer *pattern = buf_pool_get();
  struct Buffer *mailbox = buf_pool_get();
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
 
  parse_extract_token(pattern, line, TOKEN_NO_FLAGS);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  parse_extract_token(mailbox, line, TOKEN_NO_FLAGS);
 
  if (buf_is_empty(mailbox))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  const char *const c_default_hook = cs_subset_string(NeoMutt->sub, "default_hook");
  if (c_default_hook)
  {
    mutt_check_simple(pattern, c_default_hook);
  }
 
  expand_path(mailbox, false);
 
  if ((cmd->id == CMD_FCC_HOOK) || (cmd->id == CMD_FCC_SAVE_HOOK))
  {
    rc = add_mailbox_hook(CMD_FCC_HOOK, mailbox, pattern, pat_not, err);
    if (rc != MUTT_CMD_SUCCESS)
      goto cleanup;
  }
 
  if ((cmd->id == CMD_SAVE_HOOK) || (cmd->id == CMD_FCC_SAVE_HOOK))
  {
    rc = add_mailbox_hook(CMD_SAVE_HOOK, mailbox, pattern, pat_not, err);
    if (rc != MUTT_CMD_SUCCESS)
      goto cleanup;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&pattern);
  buf_pool_release(&mailbox);
  return rc;
}

Here is the call graph for this function:

parse_regex_hook()

enum CommandResult parse_regex_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse regex-based hook command - Implements Command::parse() -.

Parse:

• account-hook <regex> <command>

Definition at line 427 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  regex_t *rx = NULL;
 
  struct Buffer *regex = buf_pool_get();
  struct Buffer *command = buf_pool_get();
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
 
  parse_extract_token(regex, line, TOKEN_NO_FLAGS);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  parse_extract_token(command, line, TOKEN_SPACE);
 
  if (buf_is_empty(command))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if ((hook->id == cmd->id) && (hook->regex.pat_not == pat_not) &&
        mutt_str_equal(buf_string(regex), hook->regex.pattern))
    {
      // Ignore duplicate hooks
      if (mutt_str_equal(hook->command, buf_string(command)))
      {
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
  }
 
  /* Hooks not allowing full patterns: Check syntax of regex */
  rx = MUTT_MEM_CALLOC(1, regex_t);
  int rc2 = REG_COMP(rx, buf_string(regex), 0);
  if (rc2 != 0)
  {
    regerror(rc2, rx, err->data, err->dsize);
    buf_fix_dptr(err);
    FREE(&rx);
    goto cleanup;
  }
 
  hook = hook_new();
  hook->id = cmd->id;
  hook->command = buf_strdup(command);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = NULL;
  hook->regex.pattern = buf_strdup(regex);
  hook->regex.regex = rx;
  hook->regex.pat_not = pat_not;
  hook->expando = NULL;
 
  TAILQ_INSERT_TAIL(&mod_data->hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&regex);
  buf_pool_release(&command);
  return rc;
}

Here is the call graph for this function:

parse_folder_hook()

enum CommandResult parse_folder_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse folder hook command - Implements Command::parse() -.

Parse:

• folder-hook [ -noregex ] <regex> <command>

Definition at line 524 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  bool use_regex = true;
  regex_t *rx = NULL;
 
  struct Buffer *regex = buf_pool_get();
  struct Buffer *command = buf_pool_get();
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
 
  parse_extract_token(regex, line, TOKEN_NO_FLAGS);
  if (mutt_str_equal(buf_string(regex), "-noregex"))
  {
    use_regex = false;
    if (!MoreArgs(line))
    {
      buf_printf(err, _("%s: too few arguments"), cmd->name);
      rc = MUTT_CMD_WARNING;
      goto cleanup;
    }
    parse_extract_token(regex, line, TOKEN_NO_FLAGS);
  }
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  parse_extract_token(command, line, TOKEN_SPACE);
 
  if (buf_is_empty(command))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  /* Accidentally using the ^ mailbox shortcut in the .neomuttrc is a
   * common mistake */
  if ((buf_at(regex, 0) == '^') && !CurrentFolder)
  {
    buf_strcpy(err, _("current mailbox shortcut '^' is unset"));
    goto cleanup;
  }
 
  struct Buffer *tmp = buf_pool_get();
  buf_copy(tmp, regex);
  expand_path(tmp, use_regex);
 
  /* Check for other mailbox shortcuts that expand to the empty string.
   * This is likely a mistake too */
  if (buf_is_empty(tmp) && !buf_is_empty(regex))
  {
    buf_strcpy(err, _("mailbox shortcut expanded to empty regex"));
    buf_pool_release(&tmp);
    goto cleanup;
  }
 
  if (use_regex)
  {
    buf_copy(regex, tmp);
  }
  else
  {
    mutt_file_sanitize_regex(regex, buf_string(tmp));
  }
  buf_pool_release(&tmp);
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if ((hook->id == cmd->id) && (hook->regex.pat_not == pat_not) &&
        mutt_str_equal(buf_string(regex), hook->regex.pattern))
    {
      // Ignore duplicate hooks
      if (mutt_str_equal(hook->command, buf_string(command)))
      {
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
  }
 
  /* Hooks not allowing full patterns: Check syntax of regex */
  rx = MUTT_MEM_CALLOC(1, regex_t);
  int rc2 = REG_COMP(rx, buf_string(regex), 0);
  if (rc2 != 0)
  {
    regerror(rc2, rx, err->data, err->dsize);
    buf_fix_dptr(err);
    FREE(&rx);
    goto cleanup;
  }
 
  hook = hook_new();
  hook->id = cmd->id;
  hook->command = buf_strdup(command);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = NULL;
  hook->regex.pattern = buf_strdup(regex);
  hook->regex.regex = rx;
  hook->regex.pat_not = pat_not;
  hook->expando = NULL;
 
  TAILQ_INSERT_TAIL(&mod_data->hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&regex);
  buf_pool_release(&command);
  return rc;
}

Here is the call graph for this function:

parse_crypt_hook()

enum CommandResult parse_crypt_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse crypt hook commands - Implements Command::parse() -.

Parse:

• crypt-hook <regex> <keyid>
• pgp-hook is a deprecated synonym for crypt-hook

Definition at line 665 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  regex_t *rx = NULL;
 
  struct Buffer *regex = buf_pool_get();
  struct Buffer *keyid = buf_pool_get();
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
 
  parse_extract_token(regex, line, TOKEN_NO_FLAGS);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  parse_extract_token(keyid, line, TOKEN_NO_FLAGS);
 
  if (buf_is_empty(keyid))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if ((hook->id == cmd->id) && (hook->regex.pat_not == pat_not) &&
        mutt_str_equal(buf_string(regex), hook->regex.pattern))
    {
      // Ignore duplicate hooks
      if (mutt_str_equal(hook->command, buf_string(keyid)))
      {
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
  }
 
  /* Hooks not allowing full patterns: Check syntax of regex */
  rx = MUTT_MEM_CALLOC(1, regex_t);
  int rc2 = REG_COMP(rx, buf_string(regex), REG_ICASE);
  if (rc2 != 0)
  {
    regerror(rc2, rx, err->data, err->dsize);
    buf_fix_dptr(err);
    FREE(&rx);
    goto cleanup;
  }
 
  hook = hook_new();
  hook->id = cmd->id;
  hook->command = buf_strdup(keyid);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = NULL;
  hook->regex.pattern = buf_strdup(regex);
  hook->regex.regex = rx;
  hook->regex.pat_not = pat_not;
  hook->expando = NULL;
 
  TAILQ_INSERT_TAIL(&mod_data->hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&regex);
  buf_pool_release(&keyid);
  return rc;
}

Here is the call graph for this function:

parse_mbox_hook()

enum CommandResult parse_mbox_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse mbox hook command - Implements Command::parse() -.

Parse:

• mbox-hook [ -noregex ] <regex> <mailbox>

Definition at line 762 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  bool use_regex = true;
  regex_t *rx = NULL;
 
  struct Buffer *regex = buf_pool_get();
  struct Buffer *command = buf_pool_get();
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
 
  parse_extract_token(regex, line, TOKEN_NO_FLAGS);
  if (mutt_str_equal(buf_string(regex), "-noregex"))
  {
    use_regex = false;
    if (!MoreArgs(line))
    {
      buf_printf(err, _("%s: too few arguments"), cmd->name);
      rc = MUTT_CMD_WARNING;
      goto cleanup;
    }
    parse_extract_token(regex, line, TOKEN_NO_FLAGS);
  }
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  parse_extract_token(command, line, TOKEN_NO_FLAGS);
 
  if (buf_is_empty(command))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  /* Accidentally using the ^ mailbox shortcut in the .neomuttrc is a
   * common mistake */
  if ((buf_at(regex, 0) == '^') && !CurrentFolder)
  {
    buf_strcpy(err, _("current mailbox shortcut '^' is unset"));
    goto cleanup;
  }
 
  struct Buffer *tmp = buf_pool_get();
  buf_copy(tmp, regex);
  expand_path(tmp, use_regex);
 
  /* Check for other mailbox shortcuts that expand to the empty string.
   * This is likely a mistake too */
  if (buf_is_empty(tmp) && !buf_is_empty(regex))
  {
    buf_strcpy(err, _("mailbox shortcut expanded to empty regex"));
    buf_pool_release(&tmp);
    goto cleanup;
  }
 
  if (use_regex)
  {
    buf_copy(regex, tmp);
  }
  else
  {
    mutt_file_sanitize_regex(regex, buf_string(tmp));
  }
  buf_pool_release(&tmp);
 
  expand_path(command, false);
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if ((hook->id == cmd->id) && (hook->regex.pat_not == pat_not) &&
        mutt_str_equal(buf_string(regex), hook->regex.pattern))
    {
      // Update an existing hook
      FREE(&hook->command);
      hook->command = buf_strdup(command);
      FREE(&hook->source_file);
      hook->source_file = mutt_get_sourced_cwd();
 
      expando_free(&hook->expando);
      hook->expando = expando_parse(buf_string(command), IndexFormatDef, err);
 
      rc = MUTT_CMD_SUCCESS;
      goto cleanup;
    }
  }
 
  /* Hooks not allowing full patterns: Check syntax of regex */
  rx = MUTT_MEM_CALLOC(1, regex_t);
  int rc2 = REG_COMP(rx, buf_string(regex), 0);
  if (rc2 != 0)
  {
    regerror(rc2, rx, err->data, err->dsize);
    buf_fix_dptr(err);
    FREE(&rx);
    goto cleanup;
  }
 
  struct Expando *exp = expando_parse(buf_string(command), IndexFormatDef, err);
 
  hook = hook_new();
  hook->id = cmd->id;
  hook->command = buf_strdup(command);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = NULL;
  hook->regex.pattern = buf_strdup(regex);
  hook->regex.regex = rx;
  hook->regex.pat_not = pat_not;
  hook->expando = exp;
 
  TAILQ_INSERT_TAIL(&mod_data->hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&regex);
  buf_pool_release(&command);
  return rc;
}

Here is the call graph for this function:

parse_compress_hook()

enum CommandResult parse_compress_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse compress hook commands - Implements Command::parse() -.

Parse:

• append-hook <regex> <shell-command>
• close-hook <regex> <shell-command>
• open-hook <regex> <shell-command>

Definition at line 913 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Hook *hook = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  regex_t *rx = NULL;
 
  struct Buffer *regex = buf_pool_get();
  struct Buffer *command = buf_pool_get();
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
 
  parse_extract_token(regex, line, TOKEN_NO_FLAGS);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  // TOKEN_SPACE allows the command to contain whitespace, without quoting
  parse_extract_token(command, line, TOKEN_SPACE);
 
  if (buf_is_empty(command))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (mutt_comp_valid_command(buf_string(command)) == 0)
  {
    buf_strcpy(err, _("badly formatted command string"));
    goto cleanup;
  }
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &mod_data->hooks, entries)
  {
    if ((hook->id == cmd->id) && (hook->regex.pat_not == pat_not) &&
        mutt_str_equal(buf_string(regex), hook->regex.pattern))
    {
      // Update an existing hook
      FREE(&hook->command);
      hook->command = buf_strdup(command);
      FREE(&hook->source_file);
      hook->source_file = mutt_get_sourced_cwd();
 
      rc = MUTT_CMD_SUCCESS;
      goto cleanup;
    }
  }
 
  /* Hooks not allowing full patterns: Check syntax of regex */
  rx = MUTT_MEM_CALLOC(1, regex_t);
  int rc2 = REG_COMP(rx, buf_string(regex), 0);
  if (rc2 != 0)
  {
    regerror(rc2, rx, err->data, err->dsize);
    buf_fix_dptr(err);
    FREE(&rx);
    goto cleanup;
  }
 
  hook = hook_new();
  hook->id = cmd->id;
  hook->command = buf_strdup(command);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = NULL;
  hook->regex.pattern = buf_strdup(regex);
  hook->regex.regex = rx;
  hook->regex.pat_not = pat_not;
  hook->expando = NULL;
 
  TAILQ_INSERT_TAIL(&mod_data->hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&regex);
  buf_pool_release(&command);
  return rc;
}

Here is the call graph for this function:

parse_index_hook()

enum CommandResult parse_index_hook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the index format hook command - Implements Command::parse() -.

Parse:

• index-format-hook <name> [!]<pattern> <format-string>

Definition at line 1068 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
 
  struct Buffer *name = buf_pool_get();
  struct Buffer *pattern = buf_pool_get();
  struct Buffer *fmt = buf_pool_get();
  struct Expando *exp = NULL;
 
  if (!mod_data->idx_fmt_hooks)
  {
    mod_data->idx_fmt_hooks = mutt_hash_new(30, MUTT_HASH_STRDUP_KEYS);
    mutt_hash_set_destructor(mod_data->idx_fmt_hooks, idxfmt_hashelem_free, 0);
  }
 
  parse_extract_token(name, line, TOKEN_NO_FLAGS);
  struct HookList *hl = mutt_hash_find(mod_data->idx_fmt_hooks, buf_string(name));
 
  if (*line->dptr == '!')
  {
    line->dptr++;
    SKIPWS(line->dptr);
    pat_not = true;
  }
  parse_extract_token(pattern, line, TOKEN_NO_FLAGS);
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    goto out;
  }
  parse_extract_token(fmt, line, TOKEN_NO_FLAGS);
 
  exp = expando_parse(buf_string(fmt), IndexFormatDef, err);
  if (!exp)
    goto out;
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto out;
  }
 
  const char *const c_default_hook = cs_subset_string(NeoMutt->sub, "default_hook");
  if (c_default_hook)
    mutt_check_simple(pattern, c_default_hook);
 
  /* check to make sure that a matching hook doesn't already exist */
  struct Hook *hook = NULL;
  if (hl)
  {
    TAILQ_FOREACH(hook, hl, entries)
    {
      // Update an existing hook
      if ((hook->regex.pat_not == pat_not) &&
          mutt_str_equal(buf_string(pattern), hook->regex.pattern))
      {
        expando_free(&hook->expando);
        hook->expando = exp;
        exp = NULL;
        rc = MUTT_CMD_SUCCESS;
        goto out;
      }
    }
  }
 
  /* MUTT_PC_PATTERN_DYNAMIC sets so that date ranges are regenerated during
   * matching.  This of course is slower, but index-format-hook is commonly
   * used for date ranges, and they need to be evaluated relative to "now", not
   * the hook compilation time.  */
  struct MailboxView *mv_cur = get_current_mailbox_view();
  struct PatternList *pat = mutt_pattern_comp(mv_cur, buf_string(pattern),
                                              MUTT_PC_FULL_MSG | MUTT_PC_PATTERN_DYNAMIC,
                                              err);
  if (!pat)
    goto out;
 
  hook = hook_new();
  hook->id = CMD_INDEX_FORMAT_HOOK;
  hook->command = NULL;
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = pat;
  hook->regex.pattern = buf_strdup(pattern);
  hook->regex.regex = NULL;
  hook->regex.pat_not = pat_not;
  hook->expando = exp;
  exp = NULL;
 
  if (!hl)
  {
    hl = MUTT_MEM_CALLOC(1, struct HookList);
    TAILQ_INIT(hl);
    mutt_hash_insert(mod_data->idx_fmt_hooks, buf_string(name), hl);
  }
 
  TAILQ_INSERT_TAIL(hl, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
out:
  buf_pool_release(&name);
  buf_pool_release(&pattern);
  buf_pool_release(&fmt);
  expando_free(&exp);
 
  return rc;
}

Here is the call graph for this function:

parse_unhook()

enum CommandResult parse_unhook	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the unhook command - Implements Command::parse() -.

Parse:

• unhook { * | <hook-type> }

Definition at line 1192 of file parse.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct HooksModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_HOOKS);
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  while (MoreArgs(line))
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf_string(token)))
    {
      if (mod_data->current_hook_id != CMD_NONE)
      {
        buf_addstr(err, _("unhook: Can't do unhook * from within a hook"));
        goto done;
      }
      mutt_delete_hooks(CMD_NONE);
      delete_idxfmt_hooks();
      mutt_ch_lookup_remove();
    }
    else
    {
      const struct Command *hook = command_find_by_name(&NeoMutt->commands,
                                                        buf_string(token));
      if (!hook)
      {
        buf_printf(err, _("unhook: unknown hook type: %s"), buf_string(token));
        rc = MUTT_CMD_ERROR;
        goto done;
      }
 
      if ((hook->id == CMD_CHARSET_HOOK) || (hook->id == CMD_ICONV_HOOK))
      {
        mutt_ch_lookup_remove();
        rc = MUTT_CMD_SUCCESS;
        goto done;
      }
      if (mod_data->current_hook_id == hook->id)
      {
        buf_printf(err, _("unhook: Can't delete a %s from within a %s"),
                   buf_string(token), buf_string(token));
        rc = MUTT_CMD_WARNING;
        goto done;
      }
      if (hook->id == CMD_INDEX_FORMAT_HOOK)
        delete_idxfmt_hooks();
      else
        mutt_delete_hooks(hook->id);
    }
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_subscribe_to()

enum CommandResult parse_subscribe_to	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'subscribe-to' command - Implements Command::parse() -.

The 'subscribe-to' command allows to subscribe to an IMAP-Mailbox. Patterns are not supported.

Parse:

• subscribe-to <imap-folder-uri>

Definition at line 93 of file imap.c.

{
  struct Buffer *err = pe->message;
 
  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
  expand_path(token, false);
  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;
}

Here is the call graph for this function:

parse_unsubscribe_from()

enum CommandResult parse_unsubscribe_from	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unsubscribe-from' command - Implements Command::parse() -.

The 'unsubscribe-from' command allows to unsubscribe from an IMAP-Mailbox. Patterns are not supported.

Parse:

• unsubscribe-from <imap-folder-uri>

Definition at line 143 of file imap.c.

{
  struct Buffer *err = pe->message;
 
  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
  expand_path(token, false);
  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;
}

Here is the call graph for this function:

parse_subjectrx_list()

enum CommandResult parse_subjectrx_list	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'subject-regex' command - Implements Command::parse() -.

Parse:

• subject-regex <regex> <replacement>

Definition at line 192 of file subjectrx.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct IndexModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_INDEX);
  ASSERT(mod_data);
 
  enum CommandResult rc;
 
  rc = parse_replace_list(cmd, line, &mod_data->subject_rx_list, err);
  if (rc == MUTT_CMD_SUCCESS)
  {
    mutt_debug(LL_NOTIFY, "NT_SUBJECTRX_ADD: %s\n", cmd->name);
    notify_send(mod_data->subject_rx_notify, NT_SUBJECTRX, NT_SUBJECTRX_ADD, NULL);
  }
  return rc;
}

Here is the call graph for this function:

parse_unsubjectrx_list()

enum CommandResult parse_unsubjectrx_list	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unsubject-regex' command - Implements Command::parse() -.

Parse:

• unsubject-regex { * | <regex> }

Definition at line 224 of file subjectrx.c.

{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct IndexModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_INDEX);
  ASSERT(mod_data);
 
  enum CommandResult rc;
 
  rc = parse_unreplace_list(cmd, line, &mod_data->subject_rx_list, err);
  if (rc == MUTT_CMD_SUCCESS)
  {
    mutt_debug(LL_NOTIFY, "NT_SUBJECTRX_DELETE: %s\n", cmd->name);
    notify_send(mod_data->subject_rx_notify, NT_SUBJECTRX, NT_SUBJECTRX_DELETE, NULL);
  }
  return rc;
}

Here is the call graph for this function:

parse_dump()

enum CommandResult parse_dump	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse 'bind' and 'macro' commands - Implements Command::parse() -.

Definition at line 63 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  struct Buffer *token = buf_pool_get();
  const struct MenuDefinition *md = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  if (MoreArgs(line))
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
 
    if (MoreArgs(line))
    {
      /* More arguments potentially means the user is using the
       * ::command_t :bind command thus we delegate the task. */
      goto done;
    }
 
    if (!mutt_str_equal(buf_string(token), "all"))
    {
      md = menu_find_by_name(buf_string(token));
      if (!md)
      {
        // L10N: '%s' is the (misspelled) name of the menu, e.g. 'index' or 'pager'
        buf_printf(err, _("%s: no such menu"), buf_string(token));
        goto done;
      }
    }
  }
 
  dump_bind_macro(cmd, md, token, err);
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_push()

enum CommandResult parse_push	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'push' command - Implements Command::parse() -.

Parse:

• push <string>

Definition at line 204 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  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_CONDENSE);
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  generic_tokenize_push_string(token->data);
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_bind()

enum CommandResult parse_bind	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'bind' command - Implements Command::parse() -.

bind menu-name <key_sequence> function-name

Parse:

• bind <map>[,<map> ... ] <key> <function>

Definition at line 241 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  if (StartupComplete)
  {
    // Save and restore the offset in `line` because parse_dump() might change it
    char *dptr = line->dptr;
    if (parse_dump(cmd, line, pc, pe) == MUTT_CMD_SUCCESS)
    {
      return MUTT_CMD_SUCCESS;
    }
    if (!buf_is_empty(err))
    {
      return MUTT_CMD_ERROR;
    }
    line->dptr = dptr;
  }
 
  struct Buffer *token = buf_pool_get();
  struct Buffer *keystr = NULL;
 
  struct MenuDefinitionArray mda = ARRAY_HEAD_INITIALIZER;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  char *key = parse_keymap(cmd, &mda, line, err);
  if (!key)
    goto done;
 
  /* function to execute */
  parse_extract_token(token, line, TOKEN_NO_FLAGS);
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
  if (mutt_istr_equal("noop", buf_string(token)))
  {
    keystr = buf_pool_get();
    struct MenuDefinition **mdp = NULL;
    ARRAY_FOREACH(mdp, &mda)
    {
      struct MenuDefinition *md = *mdp;
 
      km_bind(md, key, OP_NULL, NULL, NULL, NULL); /* the 'unbind' command */
 
      buf_reset(keystr);
      keymap_expand_string(key, keystr);
      mutt_debug(LL_NOTIFY, "NT_BINDING_DELETE: %s %s\n", md->name, buf_string(keystr));
 
      int op = km_get_op_menu(md->id, buf_string(token));
 
      struct EventBinding ev_b = { md, key, op };
      notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_DELETE, &ev_b);
    }
  }
  else
  {
    keystr = buf_pool_get();
    struct MenuDefinition **mdp = NULL;
    ARRAY_FOREACH(mdp, &mda)
    {
      struct MenuDefinition *md = *mdp;
 
      int op = OP_NULL;
      struct SubMenu **ptr = NULL;
      ARRAY_FOREACH(ptr, &md->submenus)
      {
        struct SubMenu *sm = *ptr;
        const struct MenuFuncOp *mfo = NULL;
        for (int j = 0; sm->functions[j].name; j++)
        {
          mfo = &sm->functions[j];
          if (mutt_str_equal(buf_string(token), mfo->name))
          {
            op = mfo->op;
            break;
          }
        }
      }
 
      rc = km_bind(md, key, op, NULL, NULL, err);
      if (rc == MUTT_CMD_SUCCESS)
      {
        buf_reset(keystr);
        keymap_expand_string(key, keystr);
        mutt_debug(LL_NOTIFY, "NT_BINDING_NEW: %s %s\n", md->name, buf_string(keystr));
 
        struct EventBinding ev_b = { md, key, op };
        notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_ADD, &ev_b);
      }
    }
  }
 
done:
  FREE(&key);
  ARRAY_FREE(&mda);
  buf_pool_release(&keystr);
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_unbind()

enum CommandResult parse_unbind	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unbind' and 'unmacro' commands - Implements Command::parse() -.

Parse:

• unbind { * | <map>[,<map> ... ] } [ <key> ]
• unmacro { * | <map>[,<map> ... ] } [ <key> ]

Definition at line 645 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  struct ParseUnbind args = { 0 };
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  if (!parse_unbind_args(cmd, line, err, &args))
    goto done;
 
  rc = MUTT_CMD_ERROR;
  if (parse_unbind_exec(cmd, &args, err))
    rc = MUTT_CMD_SUCCESS;
 
done:
  ARRAY_FREE(&args.mda);
  FREE(&args.key);
  return rc;
}

Here is the call graph for this function:

parse_macro()

enum CommandResult parse_macro	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'macro' command - Implements Command::parse() -.

Parse:

• macro <map>[,<map> ... ] <key> <sequence> [ <description> ]

Definition at line 672 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  if (StartupComplete)
  {
    // Save and restore the offset in `line` because parse_dump() might change it
    char *dptr = line->dptr;
    if (parse_dump(cmd, line, pc, pe) == MUTT_CMD_SUCCESS)
    {
      return MUTT_CMD_SUCCESS;
    }
    if (!buf_is_empty(err))
    {
      return MUTT_CMD_ERROR;
    }
    line->dptr = dptr;
  }
 
  struct MenuDefinitionArray mda = ARRAY_HEAD_INITIALIZER;
  struct Buffer *token = buf_pool_get();
  struct Buffer *keystr = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  char *key = parse_keymap(cmd, &mda, line, err);
  if (!key)
    goto done;
 
  parse_extract_token(token, line, TOKEN_CONDENSE);
  /* make sure the macro sequence is not an empty string */
  if (buf_at(token, 0) == '\0')
  {
    buf_strcpy(err, _("macro: empty key sequence"));
  }
  else
  {
    if (MoreArgs(line))
    {
      char *seq = mutt_str_dup(buf_string(token));
      parse_extract_token(token, line, TOKEN_CONDENSE);
 
      if (MoreArgs(line))
      {
        buf_printf(err, _("%s: too many arguments"), cmd->name);
      }
      else
      {
        keystr = buf_pool_get();
        struct MenuDefinition **mdp = NULL;
        ARRAY_FOREACH(mdp, &mda)
        {
          struct MenuDefinition *md = *mdp;
 
          rc = km_bind(md, key, OP_MACRO, seq, token->data, NULL);
          if (rc == MUTT_CMD_SUCCESS)
          {
            buf_reset(keystr);
            keymap_expand_string(key, keystr);
            mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", md->name, buf_string(keystr));
 
            struct EventBinding ev_b = { md, key, OP_MACRO };
            notify_send(NeoMutt->notify, NT_BINDING, NT_MACRO_ADD, &ev_b);
            continue;
          }
        }
      }
 
      FREE(&seq);
    }
    else
    {
      keystr = buf_pool_get();
      struct MenuDefinition **mdp = NULL;
      ARRAY_FOREACH(mdp, &mda)
      {
        struct MenuDefinition *md = *mdp;
 
        rc = km_bind(md, key, OP_MACRO, token->data, NULL, NULL);
        if (rc == MUTT_CMD_SUCCESS)
        {
          buf_reset(keystr);
          keymap_expand_string(key, keystr);
          mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", md->name, buf_string(keystr));
 
          struct EventBinding ev_b = { md, key, OP_MACRO };
          notify_send(NeoMutt->notify, NT_BINDING, NT_MACRO_ADD, &ev_b);
          continue;
        }
      }
    }
  }
 
done:
  FREE(&key);
  ARRAY_FREE(&mda);
  buf_pool_release(&keystr);
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_exec()

enum CommandResult parse_exec	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'exec' command - Implements Command::parse() -.

Parse:

• exec <function> [ <function> ... ]

Definition at line 779 of file commands.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  int ops[128];
  int nops = 0;
  char *function = NULL;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NO_FLAGS);
    function = token->data;
 
    const enum MenuType mtype = menu_get_current_type();
    ops[nops] = km_get_op_menu(mtype, function);
    if (ops[nops] == OP_NULL)
    {
      mutt_flushinp();
      mutt_error(_("%s: no such function"), function);
      goto done;
    }
    nops++;
  } while (MoreArgs(line) && nops < countof(ops));
 
  while (nops)
    mutt_push_macro_event(0, ops[--nops]);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_lua()

enum CommandResult parse_lua	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'lua' command - Implements Command::parse() -.

Parse:

• lua <lua-command>

Definition at line 56 of file commands.c.

{
  struct LuaModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_LUA);
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  // From here on, use the remainder of `line`, raw
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  lua_State *lua_state = mod_data->lua_state;
  lua_init_state(&lua_state);
  mod_data->lua_state = lua_state;
  mutt_debug(LL_DEBUG2, "%s\n", line->dptr);
 
  if (luaL_dostring(lua_state, line->dptr) != LUA_OK)
  {
    mutt_debug(LL_DEBUG2, "%s -> failure\n", line->dptr);
    buf_printf(err, "%s: %s", line->dptr, lua_tostring(lua_state, -1));
    /* pop error message from the stack */
    lua_pop(lua_state, 1);
    goto done;
  }
  mutt_debug(LL_DEBUG2, "%s -> success\n", line->dptr);
  buf_reset(line); // Clear the rest of the line
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  return rc;
}

Here is the call graph for this function:

parse_lua_source()

enum CommandResult parse_lua_source	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'lua-source' command - Implements Command::parse() -.

Parse:

• lua-source <filename>

Definition at line 99 of file commands.c.

{
  struct LuaModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_LUA);
  struct Buffer *err = pe->message;
 
  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_debug(LL_DEBUG2, "enter\n");
 
  lua_State *lua_state = mod_data->lua_state;
  lua_init_state(&lua_state);
  mod_data->lua_state = lua_state;
 
  if (parse_extract_token(token, line, TOKEN_NO_FLAGS) != 0)
  {
    buf_printf(err, _("source: error at %s"), line->dptr);
    goto done;
  }
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    rc = MUTT_CMD_WARNING;
    goto done;
  }
 
  expand_path(token, false);
 
  if (luaL_dofile(lua_state, buf_string(token)) != LUA_OK)
  {
    mutt_error(_("Couldn't source lua source: %s"), lua_tostring(lua_state, -1));
    lua_pop(lua_state, 1);
    goto done;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_set()

enum CommandResult parse_set	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'set' family of commands - Implements Command::parse() -.

Parse:

• reset <variable> [ <variable> ... ]
• set [ no | inv | & ] <variable> [?] | <variable> [=|+=|-=] <value> [...]
• toggle <variable> [ <variable> ... ]
• unset <variable> [ <variable> ... ]

Definition at line 488 of file set.c.

{
  struct Buffer *err = pe->message;
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  do
  {
    bool prefix = false;
    bool query = false;
    bool inv = (cmd->id == CMD_TOGGLE);
    bool reset = (cmd->id == CMD_RESET);
    bool unset = (cmd->id == CMD_UNSET);
 
    if (*line->dptr == '?')
    {
      prefix = true;
      query = true;
      line->dptr++;
    }
    else if (mutt_str_startswith(line->dptr, "no"))
    {
      prefix = true;
      unset = !unset;
      line->dptr += 2;
    }
    else if (mutt_str_startswith(line->dptr, "inv"))
    {
      prefix = true;
      inv = !inv;
      line->dptr += 3;
    }
    else if (*line->dptr == '&')
    {
      prefix = true;
      reset = true;
      line->dptr++;
    }
 
    if (prefix && (cmd->id != CMD_SET))
    {
      buf_printf(err, _("Can't use 'inv', 'no', '&' or '?' with the '%s' command"),
                 cmd->name);
      goto done;
    }
 
    // get the variable name.  Note that token might be empty if no additional
    // argument was given.
    int ret = parse_extract_token(token, line,
                                  TOKEN_EQUAL | TOKEN_QUESTION | TOKEN_PLUS | TOKEN_MINUS);
    if (ret == -1)
    {
      buf_pool_release(&token);
      return MUTT_CMD_ERROR;
    }
 
    bool bool_or_quad = false;
    bool invertible = false;
    bool equals = false;
    bool increment = false;
    bool decrement = false;
 
    struct HashElem *he = cs_subset_lookup(NeoMutt->sub, buf_string(token));
    if (he)
    {
      // Use the correct name if a synonym is used
      buf_strcpy(token, he->key.strkey);
      bool_or_quad = ((CONFIG_TYPE(he->type) == DT_BOOL) ||
                      (CONFIG_TYPE(he->type) == DT_QUAD));
      invertible = (bool_or_quad || (CONFIG_TYPE(he->type) == DT_NUMBER));
    }
 
    if (*line->dptr == '?')
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use a prefix when querying a variable"));
        goto done;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't query option with the '%s' command"), cmd->name);
        goto done;
      }
 
      query = true;
      line->dptr++;
    }
    else if ((*line->dptr == '+') || (*line->dptr == '-'))
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use prefix when incrementing or decrementing a variable"));
        goto done;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't set option with the '%s' command"), cmd->name);
        goto done;
      }
      if (*line->dptr == '+')
        increment = true;
      else
        decrement = true;
 
      line->dptr++;
      if (*line->dptr == '=')
      {
        equals = true;
        line->dptr++;
      }
      else
      {
        buf_printf(err, _("'+' and '-' must be followed by '='"));
        goto done;
      }
    }
    else if (*line->dptr == '=')
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use prefix when setting a variable"));
        goto done;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't set option with the '%s' command"), cmd->name);
        goto done;
      }
 
      equals = true;
      line->dptr++;
    }
 
    if (!invertible && (inv || (unset && prefix)))
    {
      if (cmd->id == CMD_SET)
      {
        buf_printf(err, _("Prefixes 'no' and 'inv' may only be used with bool/quad/number variables"));
      }
      else
      {
        buf_printf(err, _("Command '%s' can only be used with bool/quad/number variables"),
                   cmd->name);
      }
      goto done;
    }
 
    // sanity checks for the above
    // Each of inv, unset reset, query, equals implies that the others are not set.
    // If none of them are set, then we are dealing with a "set foo" command.
    // clang-format off
    ASSERT(!inv    || !(       unset || reset || query || equals          ));
    ASSERT(!unset  || !(inv ||          reset || query || equals          ));
    ASSERT(!reset  || !(inv || unset ||          query || equals          ));
    ASSERT(!query  || !(inv || unset || reset ||          equals          ));
    ASSERT(!equals || !(inv || unset || reset || query ||           prefix));
    // clang-format on
    ASSERT(!(increment && decrement)); // only one of increment or decrement is set
    ASSERT(!(increment || decrement) || equals); // increment/decrement implies equals
    ASSERT(!inv || invertible); // inv (aka toggle) implies bool or quad
 
    rc = MUTT_CMD_ERROR;
    if (query)
    {
      rc = command_set_query(token, err);
      goto done; // We can only do one query even if multiple config names are given
    }
    else if (reset)
    {
      rc = command_set_reset(token, err);
    }
    else if (unset)
    {
      rc = command_set_unset(token, err);
    }
    else if (inv)
    {
      rc = command_set_toggle(token, err);
    }
    else if (equals)
    {
      // These three cases all need a value, since 'increment'/'decrement'
      // implies 'equals', we can group them in this single case guarded by
      // 'equals'.
      struct Buffer *value = buf_pool_get();
      parse_extract_token(value, line, TOKEN_BACKTICK_VARS);
      if (increment)
        rc = command_set_increment(token, value, err);
      else if (decrement)
        rc = command_set_decrement(token, value, err);
      else
        rc = command_set_set(token, value, err);
      buf_pool_release(&value);
    }
    else
    {
      // This is the "set foo" case which has different meanings depending on
      // the type of the config variable
      if (bool_or_quad)
      {
        struct Buffer *yes = buf_pool_get();
        buf_addstr(yes, "yes");
        rc = command_set_set(token, yes, err);
        buf_pool_release(&yes);
      }
      else
      {
        rc = command_set_query(token, err);
        goto done; // We can only do one query even if multiple config names are given
      }
    }
    // Short circuit (i.e. skipping further config variable names) if the action on
    // the current variable failed.
    if (rc != MUTT_CMD_SUCCESS)
      goto done;
  } while (MoreArgs(line));
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

parse_my_header()

enum CommandResult parse_my_header	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'my-header' command - Implements Command::parse() -.

Parse:

• my-header <string>

Definition at line 52 of file my_header.c.

{
  struct Buffer *err = pe->message;
 
  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 SendModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_SEND);
  ASSERT(mod_data);
 
  struct EventHeader ev_h = { token->data };
  struct ListNode *node = header_find(&mod_data->user_header, 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(&mod_data->user_header, 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_unmy_header()

enum CommandResult parse_unmy_header	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'unmy-header' command - Implements Command::parse() -.

Parse:

• unmy-header { * | <field> ... }

Definition at line 106 of file my_header.c.

{
  struct Buffer *err = pe->message;
 
  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;
 
  struct SendModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_SEND);
  ASSERT(mod_data);
 
  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, &mod_data->user_header, 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(&mod_data->user_header);
      continue;
    }
 
    l = mutt_str_len(buf_string(token));
    if (buf_at(token, l - 1) == ':')
      l--;
 
    STAILQ_FOREACH_SAFE(np, &mod_data->user_header, 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(&mod_data->user_header, np);
      }
    }
  } while (MoreArgs(line));
  buf_pool_release(&token);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_sidebar_pin()

enum CommandResult parse_sidebar_pin	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'sidebar-pin' command - Implements Command::parse() -.

Parse:

• sidebar-pin <mailbox> [ <mailbox> ... ]

Definition at line 45 of file commands.c.

{
  struct SidebarModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_SIDEBAR);
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *path = buf_pool_get();
 
  do
  {
    parse_extract_token(path, line, TOKEN_BACKTICK_VARS);
    expand_path(path, false);
    add_to_stailq(&mod_data->sidebar_pinned, buf_string(path));
  } while (MoreArgs(line));
  buf_pool_release(&path);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_sidebar_unpin()

enum CommandResult parse_sidebar_unpin	(	const struct Command *	cmd,
		struct Buffer *	line,
		const struct ParseContext *	pc,
		struct ParseError *	pe )

Parse the 'sidebar-unpin' command - Implements Command::parse() -.

Parse:

• sidebar-unpin { * | <mailbox> ... }

Definition at line 76 of file commands.c.

{
  struct SidebarModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_SIDEBAR);
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *path = buf_pool_get();
 
  do
  {
    parse_extract_token(path, line, TOKEN_BACKTICK_VARS);
    /* Check for deletion of entire list */
    if (mutt_str_equal(buf_string(path), "*"))
    {
      mutt_list_free(&mod_data->sidebar_pinned);
      break;
    }
    expand_path(path, false);
    remove_from_stailq(&mod_data->sidebar_pinned, buf_string(path));
  } while (MoreArgs(line));
  buf_pool_release(&path);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function: