parse()

Function to parse a command. More...

Collaboration diagram for parse():

Functions
enum CommandResult	parse_alias (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'alias' command - Implements Command::parse() -.
enum CommandResult	parse_unalias (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unalias' command - Implements Command::parse() -.
enum CommandResult	parse_alternates (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'alternates' command - Implements Command::parse() -.
enum CommandResult	parse_unalternates (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unalternates' command - Implements Command::parse() -.
enum CommandResult	parse_attachments (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'attachments' command - Implements Command::parse() -.
enum CommandResult	parse_unattachments (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unattachments' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_uncolor (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'uncolor' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_unmono (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unmono' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_color (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'color' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_mono (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'mono' command - Implements Command::parse() -.
static enum CommandResult	parse_cd (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'cd' command - Implements Command::parse() -.
static enum CommandResult	parse_echo (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'echo' command - Implements Command::parse() -.
static enum CommandResult	parse_finish (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'finish' command - Implements Command::parse() -.
static enum CommandResult	parse_group (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'group' and 'ungroup' commands - Implements Command::parse() -.
static enum CommandResult	parse_ifdef (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'ifdef' and 'ifndef' commands - Implements Command::parse() -.
static enum CommandResult	parse_ignore (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'ignore' command - Implements Command::parse() -.
static enum CommandResult	parse_lists (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'lists' command - Implements Command::parse() -.
enum CommandResult	parse_mailboxes (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'mailboxes' command - Implements Command::parse() -.
enum CommandResult	parse_my_hdr (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'my_hdr' command - Implements Command::parse() -.
static enum CommandResult	parse_setenv (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'setenv' and 'unsetenv' commands - Implements Command::parse() -.
static enum CommandResult	parse_source (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'source' command - Implements Command::parse() -.
static enum CommandResult	parse_nospam (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'nospam' command - Implements Command::parse() -.
static enum CommandResult	parse_spam (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'spam' command - Implements Command::parse() -.
static enum CommandResult	parse_stailq (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse a list command - Implements Command::parse() -.
static enum CommandResult	parse_subscribe (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'subscribe' command - Implements Command::parse() -.
enum CommandResult	parse_subscribe_to (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'subscribe-to' command - Implements Command::parse() -.
static enum CommandResult	parse_tag_formats (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'tag-formats' command - Implements Command::parse() -.
static enum CommandResult	parse_tag_transforms (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'tag-transforms' command - Implements Command::parse() -.
static enum CommandResult	parse_unignore (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unignore' command - Implements Command::parse() -.
static enum CommandResult	parse_unlists (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unlists' command - Implements Command::parse() -.
enum CommandResult	parse_unmailboxes (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unmailboxes' command - Implements Command::parse() -.
static enum CommandResult	parse_unmy_hdr (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unmy_hdr' command - Implements Command::parse() -.
static enum CommandResult	parse_unstailq (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse an unlist command - Implements Command::parse() -.
static enum CommandResult	parse_unsubscribe (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unsubscribe' command - Implements Command::parse() -.
enum CommandResult	parse_unsubscribe_from (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unsubscribe-from' command - Implements Command::parse() -.
static enum CommandResult	parse_version (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'version' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_charset_iconv_hook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse 'charset-hook' and 'iconv-hook' commands - Implements Command::parse() -.
enum CommandResult	mutt_parse_hook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'hook' family of commands - Implements Command::parse() -.
static enum CommandResult	mutt_parse_idxfmt_hook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'index-format-hook' command - Implements Command::parse() -.
static enum CommandResult	mutt_parse_unhook (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unhook' command - Implements Command::parse() -.
enum CommandResult	dump_bind_macro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse 'bind' and 'macro' commands - Implements Command::parse() -.
enum CommandResult	mutt_parse_push (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'push' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_bind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'bind' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_unbind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unbind' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_macro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'macro' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_exec (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'exec' command - Implements Command::parse() -.
enum CommandResult	mutt_lua_parse (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'lua' command - Implements Command::parse() -.
enum CommandResult	mutt_lua_source_file (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'lua-source' command - Implements Command::parse() -.
enum CommandResult	parse_set (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'set' family of commands - Implements Command::parse() -.
enum CommandResult	mutt_parse_score (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'score' command - Implements Command::parse() -.
enum CommandResult	mutt_parse_unscore (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unscore' command - Implements Command::parse() -.
enum CommandResult	sb_parse_sidebar_pin (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'sidebar_pin' command - Implements Command::parse() -.
enum CommandResult	sb_parse_sidebar_unpin (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'sidebar_unpin' command - Implements Command::parse() -.
static enum CommandResult	parse_unreplace_list (struct Buffer *buf, struct Buffer *s, struct ReplaceList *list, struct Buffer *err)
	Remove a string replacement rule - Implements Command::parse() -.
static enum CommandResult	parse_replace_list (struct Buffer *buf, struct Buffer *s, struct ReplaceList *list, struct Buffer *err)
	Parse a string replacement rule - Implements Command::parse() -.
enum CommandResult	parse_subjectrx_list (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'subjectrx' command - Implements Command::parse() -.
enum CommandResult	parse_unsubjectrx_list (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unsubjectrx' command - Implements Command::parse() -.

Detailed Description

Function to parse a command.

Parameters

buf	Temporary Buffer space
s	Buffer containing string to be parsed
data	Flags associated with the command
err	Buffer for error messages

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Function Documentation

parse_alias()

enum CommandResult parse_alias	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

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

Definition at line 135 of file commands.c.

{
  struct Alias *tmp = NULL;
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  enum NotifyAlias event;
 
  if (!MoreArgs(s))
  {
    buf_strcpy(err, _("alias: no address"));
    return MUTT_CMD_WARNING;
  }
 
  /* name */
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  mutt_debug(LL_DEBUG5, "First token is '%s'\n", buf->data);
  if (parse_grouplist(&gl, buf, s, err) == -1)
  {
    return MUTT_CMD_ERROR;
  }
  char *name = mutt_str_dup(buf->data);
 
  /* address list */
  parse_extract_token(buf, s, TOKEN_QUOTE | TOKEN_SPACE | TOKEN_SEMICOLON);
  mutt_debug(LL_DEBUG5, "Second token is '%s'\n", buf->data);
  struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
  int parsed = mutt_addrlist_parse2(&al, buf->data);
  if (parsed == 0)
  {
    buf_printf(err, _("Warning: Bad address '%s' in alias '%s'"), buf->data, name);
    FREE(&name);
    goto bail;
  }
 
  /* 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 bail;
  }
 
  /* check to see if an alias with this name already exists */
  TAILQ_FOREACH(tmp, &Aliases, entries)
  {
    if (mutt_istr_equal(tmp->name, name))
      break;
  }
 
  if (tmp)
  {
    FREE(&name);
    alias_reverse_delete(tmp);
    /* override the previous value */
    mutt_addrlist_clear(&tmp->addr);
    FREE(&tmp->comment);
    event = NT_ALIAS_CHANGE;
  }
  else
  {
    /* create a new alias */
    tmp = alias_new();
    tmp->name = name;
    TAILQ_INSERT_TAIL(&Aliases, tmp, entries);
    event = NT_ALIAS_ADD;
  }
  tmp->addr = al;
 
  mutt_grouplist_add_addrlist(&gl, &tmp->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 a->mailbox */
    struct Address *a = NULL;
    TAILQ_FOREACH(a, &tmp->addr, entries)
    {
      if (!a->mailbox)
        break;
 
      if (a->group)
        mutt_debug(LL_DEBUG5, "  Group %s\n", buf_string(a->mailbox));
      else
        mutt_debug(LL_DEBUG5, "  %s\n", buf_string(a->mailbox));
    }
  }
  mutt_grouplist_destroy(&gl);
  if (!MoreArgs(s) && (s->dptr[0] == '#'))
  {
    s->dptr++; // skip over the "# "
    if (*s->dptr == ' ')
      s->dptr++;
 
    parse_alias_comments(tmp, s->dptr);
    *s->dptr = '\0'; // We're done parsing
  }
 
  alias_reverse_add(tmp);
 
  mutt_debug(LL_NOTIFY, "%s: %s\n",
             (event == NT_ALIAS_ADD) ? "NT_ALIAS_ADD" : "NT_ALIAS_CHANGE", tmp->name);
  struct EventAlias ev_a = { tmp };
  notify_send(NeoMutt->notify, NT_ALIAS, event, &ev_a);
 
  return MUTT_CMD_SUCCESS;
 
bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_unalias()

enum CommandResult parse_unalias	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 251 of file commands.c.

{
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    struct Alias *np = NULL;
    if (mutt_str_equal("*", buf->data))
    {
      TAILQ_FOREACH(np, &Aliases, entries)
      {
        alias_reverse_delete(np);
      }
 
      aliaslist_clear(&Aliases);
      return MUTT_CMD_SUCCESS;
    }
 
    TAILQ_FOREACH(np, &Aliases, entries)
    {
      if (!mutt_istr_equal(buf->data, np->name))
        continue;
 
      TAILQ_REMOVE(&Aliases, np, entries);
      alias_reverse_delete(np);
      alias_free(&np);
      break;
    }
  } while (MoreArgs(s));
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_alternates()

enum CommandResult parse_alternates	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 92 of file alternates.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, buf, s, err) == -1)
      goto bail;
 
    mutt_regexlist_remove(&UnAlternates, buf->data);
 
    if (mutt_regexlist_add(&Alternates, buf->data, REG_ICASE, err) != 0)
      goto bail;
 
    if (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0)
      goto bail;
  } while (MoreArgs(s));
 
  mutt_grouplist_destroy(&gl);
 
  mutt_debug(LL_NOTIFY, "NT_ALTERN_ADD: %s\n", buf->data);
  notify_send(AlternatesNotify, NT_ALTERN, NT_ALTERN_ADD, NULL);
 
  return MUTT_CMD_SUCCESS;
 
bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_unalternates()

enum CommandResult parse_unalternates	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 128 of file alternates.c.

{
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&Alternates, buf->data);
 
    if (!mutt_str_equal(buf->data, "*") &&
        (mutt_regexlist_add(&UnAlternates, buf->data, REG_ICASE, err) != 0))
    {
      return MUTT_CMD_ERROR;
    }
 
  } while (MoreArgs(s));
 
  mutt_debug(LL_NOTIFY, "NT_ALTERN_DELETE: %s\n", buf->data);
  notify_send(AlternatesNotify, NT_ALTERN, NT_ALTERN_DELETE, NULL);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_attachments()

enum CommandResult parse_attachments	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 475 of file attachments.c.

{
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  if (!buf->data || (*buf->data == '\0'))
  {
    buf_strcpy(err, _("attachments: no disposition"));
    return MUTT_CMD_WARNING;
  }
 
  char *category = buf->data;
  char op = *category++;
 
  if (op == '?')
  {
    mutt_endwin();
    fflush(stdout);
    printf("\n%s\n\n", _("Current attachments settings:"));
    print_attach_list(&AttachAllow, '+', "A");
    print_attach_list(&AttachExclude, '-', "A");
    print_attach_list(&InlineAllow, '+', "I");
    print_attach_list(&InlineExclude, '-', "I");
    mutt_any_key_to_continue(NULL);
    return MUTT_CMD_SUCCESS;
  }
 
  if ((op != '+') && (op != '-'))
  {
    op = '+';
    category--;
  }
 
  struct ListHead *head = NULL;
  if (mutt_istr_startswith("attachment", category))
  {
    if (op == '+')
      head = &AttachAllow;
    else
      head = &AttachExclude;
  }
  else if (mutt_istr_startswith("inline", category))
  {
    if (op == '+')
      head = &InlineAllow;
    else
      head = &InlineExclude;
  }
  else
  {
    buf_strcpy(err, _("attachments: invalid disposition"));
    return MUTT_CMD_ERROR;
  }
 
  return parse_attach_list(buf, s, head, err);
}

Here is the call graph for this function:

parse_unattachments()

enum CommandResult parse_unattachments	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 534 of file attachments.c.

{
  char op;
  char *p = NULL;
  struct ListHead *head = NULL;
 
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  if (!buf->data || (*buf->data == '\0'))
  {
    buf_strcpy(err, _("unattachments: no disposition"));
    return MUTT_CMD_WARNING;
  }
 
  p = buf->data;
  op = *p++;
 
  if (op == '*')
  {
    mutt_list_free_type(&AttachAllow, (list_free_t) attachmatch_free);
    mutt_list_free_type(&AttachExclude, (list_free_t) attachmatch_free);
    mutt_list_free_type(&InlineAllow, (list_free_t) attachmatch_free);
    mutt_list_free_type(&InlineExclude, (list_free_t) attachmatch_free);
 
    mutt_debug(LL_NOTIFY, "NT_ATTACH_DELETE_ALL\n");
    notify_send(AttachmentsNotify, NT_ATTACH, NT_ATTACH_DELETE_ALL, NULL);
    return 0;
  }
 
  if ((op != '+') && (op != '-'))
  {
    op = '+';
    p--;
  }
  if (mutt_istr_startswith("attachment", p))
  {
    if (op == '+')
      head = &AttachAllow;
    else
      head = &AttachExclude;
  }
  else if (mutt_istr_startswith("inline", p))
  {
    if (op == '+')
      head = &InlineAllow;
    else
      head = &InlineExclude;
  }
  else
  {
    buf_strcpy(err, _("unattachments: invalid disposition"));
    return MUTT_CMD_ERROR;
  }
 
  return parse_unattach_list(buf, s, head, err);
}

Here is the call graph for this function:

mutt_parse_uncolor()

enum CommandResult mutt_parse_uncolor	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 477 of file command.c.

{
  if (OptNoCurses) // No GUI, so quietly discard the command
  {
    while (MoreArgs(s))
    {
      parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    }
    return MUTT_CMD_SUCCESS;
  }
 
  color_debug(LL_DEBUG5, "parse: %s\n", buf_string(buf));
  enum CommandResult rc = parse_uncolor(buf, s, err, true);
  curses_colors_dump(buf);
  return rc;
}

Here is the call graph for this function:

mutt_parse_unmono()

enum CommandResult mutt_parse_unmono	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 498 of file command.c.

{
  *s->dptr = '\0'; /* fake that we're done parsing */
  return MUTT_CMD_SUCCESS;
}

mutt_parse_color()

enum CommandResult mutt_parse_color	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 508 of file command.c.

{
  // No GUI, or no colours, so quietly discard the command
  if (OptNoCurses || (COLORS == 0))
  {
    while (MoreArgs(s))
    {
      parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    }
    return MUTT_CMD_SUCCESS;
  }
 
  color_debug(LL_DEBUG5, "parse: %s\n", buf_string(buf));
  enum CommandResult rc = parse_color(buf, s, err, parse_color_pair, true);
  curses_colors_dump(buf);
  return rc;
}

Here is the call graph for this function:

mutt_parse_mono()

enum CommandResult mutt_parse_mono	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 530 of file command.c.

{
  // No GUI, or colours available, so quietly discard the command
  if (OptNoCurses || (COLORS != 0))
  {
    while (MoreArgs(s))
    {
      parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    }
    return MUTT_CMD_SUCCESS;
  }
 
  color_debug(LL_DEBUG5, "parse: %s\n", buf_string(buf));
  enum CommandResult rc = parse_color(buf, s, err, parse_attr_spec, false);
  curses_colors_dump(buf);
  return rc;
}

Here is the call graph for this function:

parse_cd()

static enum CommandResult parse_cd ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 354 of file commands.c.

{
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  buf_expand_path(buf);
  if (buf_is_empty(buf))
  {
    if (HomeDir)
    {
      buf_strcpy(buf, HomeDir);
    }
    else
    {
      buf_printf(err, _("%s: too few arguments"), "cd");
      return MUTT_CMD_ERROR;
    }
  }
 
  if (chdir(buf_string(buf)) != 0)
  {
    buf_printf(err, "cd: %s", strerror(errno));
    return MUTT_CMD_ERROR;
  }
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_echo()

static enum CommandResult parse_echo ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 384 of file commands.c.

{
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "echo");
    return MUTT_CMD_WARNING;
  }
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  OptForceRefresh = true;
  mutt_message("%s", buf->data);
  OptForceRefresh = false;
  mutt_sleep(0);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_finish()

static enum CommandResult parse_finish ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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.

Definition at line 408 of file commands.c.

{
  if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), "finish");
    return MUTT_CMD_WARNING;
  }
 
  return MUTT_CMD_FINISH;
}

Here is the call graph for this function:

parse_group()

static enum CommandResult parse_group ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 423 of file commands.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
  enum GroupState gstate = GS_NONE;
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    if (parse_grouplist(&gl, buf, s, err) == -1)
      goto bail;
 
    if ((data == MUTT_UNGROUP) && mutt_istr_equal(buf->data, "*"))
    {
      mutt_grouplist_clear(&gl);
      goto out;
    }
 
    if (mutt_istr_equal(buf->data, "-rx"))
    {
      gstate = GS_RX;
    }
    else if (mutt_istr_equal(buf->data, "-addr"))
    {
      gstate = GS_ADDR;
    }
    else
    {
      switch (gstate)
      {
        case GS_NONE:
          buf_printf(err, _("%sgroup: missing -rx or -addr"),
                     (data == MUTT_UNGROUP) ? "un" : "");
          goto warn;
 
        case GS_RX:
          if ((data == MUTT_GROUP) &&
              (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0))
          {
            goto bail;
          }
          else if ((data == MUTT_UNGROUP) &&
                   (mutt_grouplist_remove_regex(&gl, buf->data) < 0))
          {
            goto bail;
          }
          break;
 
        case GS_ADDR:
        {
          char *estr = NULL;
          struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
          mutt_addrlist_parse2(&al, buf->data);
          if (TAILQ_EMPTY(&al))
            goto bail;
          if (mutt_addrlist_to_intl(&al, &estr))
          {
            buf_printf(err, _("%sgroup: warning: bad IDN '%s'"),
                       (data == 1) ? "un" : "", estr);
            mutt_addrlist_clear(&al);
            FREE(&estr);
            goto bail;
          }
          if (data == MUTT_GROUP)
            mutt_grouplist_add_addrlist(&gl, &al);
          else if (data == MUTT_UNGROUP)
            mutt_grouplist_remove_addrlist(&gl, &al);
          mutt_addrlist_clear(&al);
          break;
        }
      }
    }
  } while (MoreArgs(s));
 
out:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;
 
bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
 
warn:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_WARNING;
}

Here is the call graph for this function:

parse_ifdef()

static enum CommandResult parse_ifdef ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

If (data == 1) then it means use the 'ifndef' (if-not-defined) command. e.g. ifndef imap finish

Definition at line 523 of file commands.c.

{
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  if (buf_is_empty(buf))
  {
    buf_printf(err, _("%s: too few arguments"), (data ? "ifndef" : "ifdef"));
    return MUTT_CMD_WARNING;
  }
 
  // is the item defined as:
  bool res = cs_subset_lookup(NeoMutt->sub, buf->data) // a variable?
             || feature_enabled(buf->data)             // a compiled-in feature?
             || is_function(buf->data)                 // a function?
             || command_get(buf->data)                 // a command?
#ifdef USE_HCACHE
             || store_is_valid_backend(buf->data) // a store? (database)
#endif
             || mutt_str_getenv(buf->data); // an environment variable?
 
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), (data ? "ifndef" : "ifdef"));
    return MUTT_CMD_WARNING;
  }
  parse_extract_token(buf, s, TOKEN_SPACE);
 
  /* ifdef KNOWN_SYMBOL or ifndef UNKNOWN_SYMBOL */
  if ((res && (data == 0)) || (!res && (data == 1)))
  {
    enum CommandResult rc = parse_rc_line(buf->data, err);
    if (rc == MUTT_CMD_ERROR)
    {
      mutt_error(_("Error: %s"), buf_string(err));
      return MUTT_CMD_ERROR;
    }
    return rc;
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_ignore()

static enum CommandResult parse_ignore ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 568 of file commands.c.

{
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    remove_from_stailq(&UnIgnore, buf->data);
    add_to_stailq(&Ignore, buf->data);
  } while (MoreArgs(s));
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_lists()

static enum CommandResult parse_lists ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 584 of file commands.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, buf, s, err) == -1)
      goto bail;
 
    mutt_regexlist_remove(&UnMailLists, buf->data);
 
    if (mutt_regexlist_add(&MailLists, buf->data, REG_ICASE, err) != 0)
      goto bail;
 
    if (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0)
      goto bail;
  } while (MoreArgs(s));
 
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;
 
bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_mailboxes()

enum CommandResult parse_mailboxes	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

This is also used by 'virtual-mailboxes'.

Definition at line 739 of file commands.c.

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

Here is the call graph for this function:

parse_my_hdr()

enum CommandResult parse_my_hdr	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 835 of file commands.c.

{
  parse_extract_token(buf, s, TOKEN_SPACE | TOKEN_QUOTE);
  char *p = strpbrk(buf->data, ": \t");
  if (!p || (*p != ':'))
  {
    buf_strcpy(err, _("invalid header field"));
    return MUTT_CMD_WARNING;
  }
 
  struct EventHeader ev_h = { buf->data };
  struct ListNode *n = header_find(&UserHeader, buf->data);
 
  if (n)
  {
    header_update(n, buf->data);
    mutt_debug(LL_NOTIFY, "NT_HEADER_CHANGE: %s\n", buf->data);
    notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_CHANGE, &ev_h);
  }
  else
  {
    header_add(&UserHeader, buf->data);
    mutt_debug(LL_NOTIFY, "NT_HEADER_ADD: %s\n", buf->data);
    notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_ADD, &ev_h);
  }
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_setenv()

static enum CommandResult parse_setenv ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 918 of file commands.c.

{
  char **envp = EnvList;
 
  bool query = false;
  bool prefix = false;
  bool unset = (data == MUTT_SET_UNSET);
 
  if (!MoreArgs(s))
  {
    if (!StartupComplete)
    {
      buf_printf(err, _("%s: too few arguments"), "setenv");
      return MUTT_CMD_WARNING;
    }
 
    struct Buffer *tempfile = buf_pool_get();
    buf_mktemp(tempfile);
 
    FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w");
    if (!fp_out)
    {
      // L10N: '%s' is the file name of the temporary file
      buf_printf(err, _("Could not create temporary file %s"), buf_string(tempfile));
      buf_pool_release(&tempfile);
      return MUTT_CMD_ERROR;
    }
 
    int count = 0;
    for (char **env = EnvList; *env; env++)
      count++;
 
    mutt_qsort_r(EnvList, count, sizeof(char *), envlist_sort, NULL);
 
    for (char **env = EnvList; *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 = "setenv";
    pview.flags = MUTT_PAGER_NO_FLAGS;
    pview.mode = PAGER_MODE_OTHER;
 
    mutt_do_pager(&pview, NULL);
    buf_pool_release(&tempfile);
 
    return MUTT_CMD_SUCCESS;
  }
 
  if (*s->dptr == '?')
  {
    query = true;
    prefix = true;
 
    if (unset)
    {
      buf_printf(err, _("Can't query option with the '%s' command"), "unsetenv");
      return MUTT_CMD_WARNING;
    }
 
    s->dptr++;
  }
 
  /* get variable name */
  parse_extract_token(buf, s, TOKEN_EQUAL | TOKEN_QUESTION);
 
  if (*s->dptr == '?')
  {
    if (unset)
    {
      buf_printf(err, _("Can't query option with the '%s' command"), "unsetenv");
      return MUTT_CMD_WARNING;
    }
 
    if (prefix)
    {
      buf_printf(err, _("Can't use a prefix when querying a variable"));
      return MUTT_CMD_WARNING;
    }
 
    query = true;
    s->dptr++;
  }
 
  if (query)
  {
    bool found = false;
    while (envp && *envp)
    {
      /* This will display all matches for "^QUERY" */
      if (mutt_str_startswith(*envp, buf->data))
      {
        if (!found)
        {
          mutt_endwin();
          found = true;
        }
        puts(*envp);
      }
      envp++;
    }
 
    if (found)
    {
      mutt_any_key_to_continue(NULL);
      return MUTT_CMD_SUCCESS;
    }
 
    buf_printf(err, _("%s is unset"), buf->data);
    return MUTT_CMD_WARNING;
  }
 
  if (unset)
  {
    if (!envlist_unset(&EnvList, buf->data))
    {
      buf_printf(err, _("%s is unset"), buf->data);
      return MUTT_CMD_WARNING;
    }
    return MUTT_CMD_SUCCESS;
  }
 
  /* set variable */
 
  if (*s->dptr == '=')
  {
    s->dptr++;
    SKIPWS(s->dptr);
  }
 
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "setenv");
    return MUTT_CMD_WARNING;
  }
 
  char *name = mutt_str_dup(buf->data);
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  envlist_set(&EnvList, name, buf->data, true);
  FREE(&name);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_source()

static enum CommandResult parse_source ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1071 of file commands.c.

{
  struct Buffer *path = buf_pool_get();
 
  do
  {
    if (parse_extract_token(buf, s, TOKEN_NO_FLAGS) != 0)
    {
      buf_printf(err, _("source: error at %s"), s->dptr);
      buf_pool_release(&path);
      return MUTT_CMD_ERROR;
    }
    buf_copy(path, buf);
    buf_expand_path(path);
 
    if (source_rc(buf_string(path), err) < 0)
    {
      buf_printf(err, _("source: file %s could not be sourced"), buf_string(path));
      buf_pool_release(&path);
      return MUTT_CMD_ERROR;
    }
 
  } while (MoreArgs(s));
 
  buf_pool_release(&path);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_nospam()

static enum CommandResult parse_nospam ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1104 of file commands.c.

{
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "nospam");
    return MUTT_CMD_ERROR;
  }
 
  // Extract the first token, a regex or "*"
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), "finish");
    return MUTT_CMD_ERROR;
  }
 
  // "*" is special - clear both spam and nospam lists
  if (mutt_str_equal(buf_string(buf), "*"))
  {
    mutt_replacelist_free(&SpamList);
    mutt_regexlist_free(&NoSpamList);
    return MUTT_CMD_SUCCESS;
  }
 
  // If it's on the spam list, just remove it
  if (mutt_replacelist_remove(&SpamList, buf_string(buf)) != 0)
    return MUTT_CMD_SUCCESS;
 
  // Otherwise, add it to the nospam list
  if (mutt_regexlist_add(&NoSpamList, buf_string(buf), REG_ICASE, err) != 0)
    return MUTT_CMD_ERROR;
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_spam()

static enum CommandResult parse_spam ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1144 of file commands.c.

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

Here is the call graph for this function:

parse_stailq()

static enum CommandResult parse_stailq ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

This is used by 'alternative_order', 'auto_view' and several others.

Definition at line 1182 of file commands.c.

{
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    add_to_stailq((struct ListHead *) data, buf->data);
  } while (MoreArgs(s));
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_subscribe()

static enum CommandResult parse_subscribe ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1197 of file commands.c.

{
  struct GroupList gl = STAILQ_HEAD_INITIALIZER(gl);
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (parse_grouplist(&gl, buf, s, err) == -1)
      goto bail;
 
    mutt_regexlist_remove(&UnMailLists, buf->data);
    mutt_regexlist_remove(&UnSubscribedLists, buf->data);
 
    if (mutt_regexlist_add(&MailLists, buf->data, REG_ICASE, err) != 0)
      goto bail;
    if (mutt_regexlist_add(&SubscribedLists, buf->data, REG_ICASE, err) != 0)
      goto bail;
    if (mutt_grouplist_add_regex(&gl, buf->data, REG_ICASE, err) != 0)
      goto bail;
  } while (MoreArgs(s));
 
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_SUCCESS;
 
bail:
  mutt_grouplist_destroy(&gl);
  return MUTT_CMD_ERROR;
}

Here is the call graph for this function:

parse_subscribe_to()

enum CommandResult parse_subscribe_to	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

The 'subscribe-to' command allows to subscribe to an IMAP-Mailbox. Patterns are not supported. Use it as follows: subscribe-to =folder

Definition at line 1235 of file commands.c.

{
  if (!buf || !s || !err)
    return MUTT_CMD_ERROR;
 
  buf_reset(err);
 
  if (MoreArgs(s))
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (MoreArgs(s))
    {
      buf_printf(err, _("%s: too many arguments"), "subscribe-to");
      return MUTT_CMD_WARNING;
    }
 
    if (!buf_is_empty(buf))
    {
      /* Expand and subscribe */
      buf_expand_path(buf);
      if (imap_subscribe(buf_string(buf), true) == 0)
      {
        mutt_message(_("Subscribed to %s"), buf->data);
        return MUTT_CMD_SUCCESS;
      }
 
      buf_printf(err, _("Could not subscribe to %s"), buf->data);
      return MUTT_CMD_ERROR;
    }
 
    mutt_debug(LL_DEBUG1, "Corrupted buffer");
    return MUTT_CMD_ERROR;
  }
 
  buf_addstr(err, _("No folder specified"));
  return MUTT_CMD_WARNING;
}

Here is the call graph for this function:

parse_tag_formats()

static enum CommandResult parse_tag_formats ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Parse config like: tag-formats pgp GP

Note

This maps format -> tag

Definition at line 1282 of file commands.c.

{
  if (!s)
    return MUTT_CMD_ERROR;
 
  struct Buffer *tagbuf = buf_pool_get();
  struct Buffer *fmtbuf = buf_pool_get();
 
  while (MoreArgs(s))
  {
    parse_extract_token(tagbuf, s, TOKEN_NO_FLAGS);
    const char *tag = buf_string(tagbuf);
    if (*tag == '\0')
      continue;
 
    parse_extract_token(fmtbuf, s, TOKEN_NO_FLAGS);
    const char *fmt = buf_string(fmtbuf);
 
    /* avoid duplicates */
    const char *tmp = mutt_hash_find(TagFormats, fmt);
    if (tmp)
    {
      mutt_warning(_("tag format '%s' already registered as '%s'"), fmt, tmp);
      continue;
    }
 
    mutt_hash_insert(TagFormats, fmt, mutt_str_dup(tag));
  }
 
  buf_pool_release(&tagbuf);
  buf_pool_release(&fmtbuf);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_tag_transforms()

static enum CommandResult parse_tag_transforms ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Parse config like: tag-transforms pgp P

Note

This maps tag -> transform

Definition at line 1324 of file commands.c.

{
  if (!s)
    return MUTT_CMD_ERROR;
 
  struct Buffer *tagbuf = buf_pool_get();
  struct Buffer *trnbuf = buf_pool_get();
 
  while (MoreArgs(s))
  {
    parse_extract_token(tagbuf, s, TOKEN_NO_FLAGS);
    const char *tag = buf_string(tagbuf);
    if (*tag == '\0')
      continue;
 
    parse_extract_token(trnbuf, s, TOKEN_NO_FLAGS);
    const char *trn = buf_string(trnbuf);
 
    /* avoid duplicates */
    const char *tmp = mutt_hash_find(TagTransforms, tag);
    if (tmp)
    {
      mutt_warning(_("tag transform '%s' already registered as '%s'"), tag, tmp);
      continue;
    }
 
    mutt_hash_insert(TagTransforms, tag, mutt_str_dup(trn));
  }
 
  buf_pool_release(&tagbuf);
  buf_pool_release(&trnbuf);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unignore()

static enum CommandResult parse_unignore ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1362 of file commands.c.

{
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    /* don't add "*" to the unignore list */
    if (!mutt_str_equal(buf->data, "*"))
      add_to_stailq(&UnIgnore, buf->data);
 
    remove_from_stailq(&Ignore, buf->data);
  } while (MoreArgs(s));
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unlists()

static enum CommandResult parse_unlists ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1382 of file commands.c.

{
  mutt_hash_free(&AutoSubscribeCache);
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&SubscribedLists, buf->data);
    mutt_regexlist_remove(&MailLists, buf->data);
 
    if (!mutt_str_equal(buf->data, "*") &&
        (mutt_regexlist_add(&UnMailLists, buf->data, REG_ICASE, err) != 0))
    {
      return MUTT_CMD_ERROR;
    }
  } while (MoreArgs(s));
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unmailboxes()

enum CommandResult parse_unmailboxes	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

This is also used by 'unvirtual-mailboxes'

Definition at line 1448 of file commands.c.

{
  while (MoreArgs(s))
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (mutt_str_equal(buf->data, "*"))
    {
      do_unmailboxes_star();
      return MUTT_CMD_SUCCESS;
    }
 
    buf_expand_path(buf);
 
    struct Account *a = NULL;
    TAILQ_FOREACH(a, &NeoMutt->accounts, entries)
    {
      struct Mailbox *m = mx_mbox_find(a, buf_string(buf));
      if (m)
      {
        do_unmailboxes(m);
        break;
      }
    }
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unmy_hdr()

static enum CommandResult parse_unmy_hdr ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1480 of file commands.c.

{
  struct ListNode *np = NULL, *tmp = NULL;
  size_t l;
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf->data))
    {
      /* Clear all headers, send a notification for each header */
      STAILQ_FOREACH(np, &UserHeader, entries)
      {
        mutt_debug(LL_NOTIFY, "NT_HEADER_DELETE: %s\n", np->data);
        struct EventHeader ev_h = { np->data };
        notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_DELETE, &ev_h);
      }
      mutt_list_free(&UserHeader);
      continue;
    }
 
    l = mutt_str_len(buf->data);
    if (buf->data[l - 1] == ':')
      l--;
 
    STAILQ_FOREACH_SAFE(np, &UserHeader, entries, tmp)
    {
      if (mutt_istrn_equal(buf->data, np->data, l) && (np->data[l] == ':'))
      {
        mutt_debug(LL_NOTIFY, "NT_HEADER_DELETE: %s\n", np->data);
        struct EventHeader ev_h = { np->data };
        notify_send(NeoMutt->notify, NT_HEADER, NT_HEADER_DELETE, &ev_h);
 
        header_free(&UserHeader, np);
      }
    }
  } while (MoreArgs(s));
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unstailq()

static enum CommandResult parse_unstailq ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

This is used by 'unalternative_order', 'unauto_view' and several others.

Definition at line 1526 of file commands.c.

{
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    /* Check for deletion of entire list */
    if (mutt_str_equal(buf->data, "*"))
    {
      mutt_list_free((struct ListHead *) data);
      break;
    }
    remove_from_stailq((struct ListHead *) data, buf->data);
  } while (MoreArgs(s));
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unsubscribe()

static enum CommandResult parse_unsubscribe ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1547 of file commands.c.

{
  mutt_hash_free(&AutoSubscribeCache);
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    mutt_regexlist_remove(&SubscribedLists, buf->data);
 
    if (!mutt_str_equal(buf->data, "*") &&
        (mutt_regexlist_add(&UnSubscribedLists, buf->data, REG_ICASE, err) != 0))
    {
      return MUTT_CMD_ERROR;
    }
  } while (MoreArgs(s));
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_unsubscribe_from()

enum CommandResult parse_unsubscribe_from	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

The 'unsubscribe-from' command allows to unsubscribe from an IMAP-Mailbox. Patterns are not supported. Use it as follows: unsubscribe-from =folder

Definition at line 1573 of file commands.c.

{
  if (!buf || !s || !err)
    return MUTT_CMD_ERROR;
 
  if (MoreArgs(s))
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (MoreArgs(s))
    {
      buf_printf(err, _("%s: too many arguments"), "unsubscribe-from");
      return MUTT_CMD_WARNING;
    }
 
    if (buf->data && (*buf->data != '\0'))
    {
      /* Expand and subscribe */
      buf_expand_path(buf);
      if (imap_subscribe(buf_string(buf), false) == 0)
      {
        mutt_message(_("Unsubscribed from %s"), buf->data);
        return MUTT_CMD_SUCCESS;
      }
 
      buf_printf(err, _("Could not unsubscribe from %s"), buf->data);
      return MUTT_CMD_ERROR;
    }
 
    mutt_debug(LL_DEBUG1, "Corrupted buffer");
    return MUTT_CMD_ERROR;
  }
 
  buf_addstr(err, _("No folder specified"));
  return MUTT_CMD_WARNING;
}

Here is the call graph for this function:

parse_version()

static enum CommandResult parse_version ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 1614 of file commands.c.

{
  // silently ignore 'version' if it's in a config file
  if (!StartupComplete)
    return MUTT_CMD_SUCCESS;
 
  struct Buffer *tempfile = buf_pool_get();
  buf_mktemp(tempfile);
 
  FILE *fp_out = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_out)
  {
    // L10N: '%s' is the file name of the temporary file
    buf_printf(err, _("Could not create temporary file %s"), buf_string(tempfile));
    buf_pool_release(&tempfile);
    return MUTT_CMD_ERROR;
  }
 
  print_version(fp_out);
  mutt_file_fclose(&fp_out);
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pdata.fname = buf_string(tempfile);
 
  pview.banner = "version";
  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:

mutt_parse_charset_iconv_hook()

enum CommandResult mutt_parse_charset_iconv_hook	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

Parse 'charset-hook' and 'iconv-hook' commands - Implements Command::parse() -.

Definition at line 123 of file hook.c.

{
  struct Buffer *alias = buf_pool_get();
  struct Buffer *charset = buf_pool_get();
 
  int rc = MUTT_CMD_ERROR;
 
  if (parse_extract_token(alias, s, TOKEN_NO_FLAGS) < 0)
    goto done;
  if (parse_extract_token(charset, s, TOKEN_NO_FLAGS) < 0)
    goto done;
 
  const enum LookupType type = (data & MUTT_ICONV_HOOK) ? MUTT_LOOKUP_ICONV : MUTT_LOOKUP_CHARSET;
 
  if (buf_is_empty(alias) || buf_is_empty(charset))
  {
    buf_printf(err, _("%s: too few arguments"), buf->data);
    rc = MUTT_CMD_WARNING;
  }
  else if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), buf->data);
    buf_reset(s); // 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:

mutt_parse_hook()

enum CommandResult mutt_parse_hook	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

This is used by 'account-hook', 'append-hook' and many more.

Definition at line 166 of file hook.c.

{
  struct Hook *hook = NULL;
  int rc = MUTT_CMD_ERROR;
  bool pat_not = false;
  bool use_regex = true;
  regex_t *rx = NULL;
  struct PatternList *pat = NULL;
  const bool folder_or_mbox = (data & (MUTT_FOLDER_HOOK | MUTT_MBOX_HOOK));
 
  struct Buffer *cmd = buf_pool_get();
  struct Buffer *pattern = buf_pool_get();
 
  if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
  {
    if (*s->dptr == '!')
    {
      s->dptr++;
      SKIPWS(s->dptr);
      pat_not = true;
    }
 
    parse_extract_token(pattern, s, TOKEN_NO_FLAGS);
    if (folder_or_mbox && mutt_str_equal(buf_string(pattern), "-noregex"))
    {
      use_regex = false;
      if (!MoreArgs(s))
      {
        buf_printf(err, _("%s: too few arguments"), buf->data);
        rc = MUTT_CMD_WARNING;
        goto cleanup;
      }
      parse_extract_token(pattern, s, TOKEN_NO_FLAGS);
    }
 
    if (!MoreArgs(s))
    {
      buf_printf(err, _("%s: too few arguments"), buf->data);
      rc = MUTT_CMD_WARNING;
      goto cleanup;
    }
  }
 
  parse_extract_token(cmd, s,
                      (data & (MUTT_FOLDER_HOOK | MUTT_SEND_HOOK | MUTT_SEND2_HOOK |
                               MUTT_ACCOUNT_HOOK | MUTT_REPLY_HOOK)) ?
                          TOKEN_SPACE :
                          TOKEN_NO_FLAGS);
 
  if (buf_is_empty(cmd))
  {
    buf_printf(err, _("%s: too few arguments"), buf->data);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), buf->data);
    rc = MUTT_CMD_WARNING;
    goto cleanup;
  }
 
  const char *const c_default_hook = cs_subset_string(NeoMutt->sub, "default_hook");
  if (folder_or_mbox)
  {
    /* Accidentally using the ^ mailbox shortcut in the .neomuttrc is a
     * common mistake */
    if ((pattern->data[0] == '^') && !CurrentFolder)
    {
      buf_strcpy(err, _("current mailbox shortcut '^' is unset"));
      goto cleanup;
    }
 
    struct Buffer *tmp = buf_pool_get();
    buf_copy(tmp, pattern);
    buf_expand_path_regex(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(pattern))
    {
      buf_strcpy(err, _("mailbox shortcut expanded to empty regex"));
      buf_pool_release(&tmp);
      goto cleanup;
    }
 
    if (use_regex)
    {
      buf_copy(pattern, tmp);
    }
    else
    {
      mutt_file_sanitize_regex(pattern, buf_string(tmp));
    }
    buf_pool_release(&tmp);
  }
  else if (data & (MUTT_APPEND_HOOK | MUTT_OPEN_HOOK | MUTT_CLOSE_HOOK))
  {
    if (mutt_comp_valid_command(buf_string(cmd)) == 0)
    {
      buf_strcpy(err, _("badly formatted command string"));
      goto cleanup;
    }
  }
  else if (c_default_hook && (~data & MUTT_GLOBAL_HOOK) &&
           !(data & (MUTT_ACCOUNT_HOOK)) && (!WithCrypto || !(data & MUTT_CRYPT_HOOK)))
  {
    /* At this stage only these hooks remain:
     * fcc-, fcc-save-, index-format-, message-, reply-, save-, send- and send2-hook
     * If given a plain string, or regex, we expand it using $default_hook. */
    mutt_check_simple(pattern, c_default_hook);
  }
 
  if (data & (MUTT_MBOX_HOOK | MUTT_SAVE_HOOK | MUTT_FCC_HOOK))
  {
    buf_expand_path(cmd);
  }
 
  /* check to make sure that a matching hook doesn't already exist */
  TAILQ_FOREACH(hook, &Hooks, entries)
  {
    if (data & MUTT_GLOBAL_HOOK)
    {
      /* Ignore duplicate global hooks */
      if (mutt_str_equal(hook->command, buf_string(cmd)))
      {
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
    else if ((hook->type == data) && (hook->regex.pat_not == pat_not) &&
             mutt_str_equal(buf_string(pattern), hook->regex.pattern))
    {
      if (data & (MUTT_FOLDER_HOOK | MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_MESSAGE_HOOK |
                  MUTT_ACCOUNT_HOOK | MUTT_REPLY_HOOK | MUTT_CRYPT_HOOK |
                  MUTT_TIMEOUT_HOOK | MUTT_STARTUP_HOOK | MUTT_SHUTDOWN_HOOK))
      {
        /* 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(cmd)))
        {
          rc = MUTT_CMD_SUCCESS;
          goto cleanup;
        }
      }
      else
      {
        /* other hooks only allow one command per pattern, so update the
         * entry with the new command.  this currently does not change the
         * order of execution of the hooks, which i think is desirable since
         * a common action to perform is to change the default (.) entry
         * based upon some other information. */
        FREE(&hook->command);
        hook->command = buf_strdup(cmd);
        FREE(&hook->source_file);
        hook->source_file = mutt_get_sourced_cwd();
 
        if (data & (MUTT_IDXFMTHOOK | MUTT_MBOX_HOOK | MUTT_SAVE_HOOK | MUTT_FCC_HOOK))
        {
          expando_free(&hook->expando);
          hook->expando = expando_parse(buf_string(cmd), IndexFormatDef, err);
        }
 
        rc = MUTT_CMD_SUCCESS;
        goto cleanup;
      }
    }
  }
 
  if (data & (MUTT_SEND_HOOK | MUTT_SEND2_HOOK | MUTT_SAVE_HOOK |
              MUTT_FCC_HOOK | MUTT_MESSAGE_HOOK | MUTT_REPLY_HOOK))
  {
    PatternCompFlags comp_flags;
 
    if (data & (MUTT_SEND2_HOOK))
      comp_flags = MUTT_PC_SEND_MODE_SEARCH;
    else if (data & (MUTT_SEND_HOOK | MUTT_FCC_HOOK))
      comp_flags = MUTT_PC_NO_FLAGS;
    else
      comp_flags = MUTT_PC_FULL_MSG;
 
    struct MailboxView *mv_cur = get_current_mailbox_view();
    struct Menu *menu = get_current_menu();
    pat = mutt_pattern_comp(mv_cur, menu, buf_string(pattern), comp_flags, err);
    if (!pat)
      goto cleanup;
  }
  else if (~data & MUTT_GLOBAL_HOOK) /* NOT a global hook */
  {
    /* Hooks not allowing full patterns: Check syntax of regex */
    rx = MUTT_MEM_CALLOC(1, regex_t);
    int rc2 = REG_COMP(rx, buf_string(pattern), ((data & MUTT_CRYPT_HOOK) ? REG_ICASE : 0));
    if (rc2 != 0)
    {
      regerror(rc2, rx, err->data, err->dsize);
      FREE(&rx);
      goto cleanup;
    }
  }
 
  struct Expando *exp = NULL;
  if (data & (MUTT_IDXFMTHOOK | MUTT_MBOX_HOOK | MUTT_SAVE_HOOK | MUTT_FCC_HOOK))
    exp = expando_parse(buf_string(cmd), IndexFormatDef, err);
 
  hook = hook_new();
  hook->type = data;
  hook->command = buf_strdup(cmd);
  hook->source_file = mutt_get_sourced_cwd();
  hook->pattern = pat;
  hook->regex.pattern = buf_strdup(pattern);
  hook->regex.regex = rx;
  hook->regex.pat_not = pat_not;
  hook->expando = exp;
 
  TAILQ_INSERT_TAIL(&Hooks, hook, entries);
  rc = MUTT_CMD_SUCCESS;
 
cleanup:
  buf_pool_release(&cmd);
  buf_pool_release(&pattern);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_idxfmt_hook()

static enum CommandResult mutt_parse_idxfmt_hook ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 442 of file hook.c.

{
  enum CommandResult rc = MUTT_CMD_ERROR;
  bool pat_not = false;
 
  struct Buffer *name = buf_pool_get();
  struct Buffer *pattern = buf_pool_get();
  struct Buffer *fmtstring = buf_pool_get();
  struct Expando *exp = NULL;
 
  if (!IdxFmtHooks)
  {
    IdxFmtHooks = mutt_hash_new(30, MUTT_HASH_STRDUP_KEYS);
    mutt_hash_set_destructor(IdxFmtHooks, idxfmt_hashelem_free, 0);
  }
 
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), buf->data);
    goto out;
  }
  parse_extract_token(name, s, TOKEN_NO_FLAGS);
  struct HookList *hl = mutt_hash_find(IdxFmtHooks, buf_string(name));
 
  if (*s->dptr == '!')
  {
    s->dptr++;
    SKIPWS(s->dptr);
    pat_not = true;
  }
  parse_extract_token(pattern, s, TOKEN_NO_FLAGS);
 
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), buf->data);
    goto out;
  }
  parse_extract_token(fmtstring, s, TOKEN_NO_FLAGS);
 
  exp = expando_parse(buf_string(fmtstring), IndexFormatDef, err);
  if (!exp)
    goto out;
 
  if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), buf->data);
    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)
    {
      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 Menu *menu = get_current_menu();
  struct PatternList *pat = mutt_pattern_comp(mv_cur, menu, buf_string(pattern),
                                              MUTT_PC_FULL_MSG | MUTT_PC_PATTERN_DYNAMIC,
                                              err);
  if (!pat)
    goto out;
 
  hook = hook_new();
  hook->type = MUTT_IDXFMTHOOK;
  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(IdxFmtHooks, 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(&fmtstring);
  expando_free(&exp);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_unhook()

static enum CommandResult mutt_parse_unhook ( struct Buffer *  buf, struct Buffer *  s, intptr_t  data, struct Buffer *  err  )

static

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

Definition at line 579 of file hook.c.

{
  while (MoreArgs(s))
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf->data))
    {
      if (CurrentHookType != TOKEN_NO_FLAGS)
      {
        buf_addstr(err, _("unhook: Can't do unhook * from within a hook"));
        return MUTT_CMD_WARNING;
      }
      mutt_delete_hooks(MUTT_HOOK_NO_FLAGS);
      delete_idxfmt_hooks();
      mutt_ch_lookup_remove();
    }
    else
    {
      HookFlags type = mutt_get_hook_type(buf->data);
 
      if (type == MUTT_HOOK_NO_FLAGS)
      {
        buf_printf(err, _("unhook: unknown hook type: %s"), buf->data);
        return MUTT_CMD_ERROR;
      }
      if (type & (MUTT_CHARSET_HOOK | MUTT_ICONV_HOOK))
      {
        mutt_ch_lookup_remove();
        return MUTT_CMD_SUCCESS;
      }
      if (CurrentHookType == type)
      {
        buf_printf(err, _("unhook: Can't delete a %s from within a %s"),
                   buf->data, buf->data);
        return MUTT_CMD_WARNING;
      }
      if (type == MUTT_IDXFMTHOOK)
        delete_idxfmt_hooks();
      else
        mutt_delete_hooks(type);
    }
  }
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

dump_bind_macro()

enum CommandResult dump_bind_macro	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 172 of file dump.c.

{
  FILE *fp_out = NULL;
  bool dump_all = false, bind = (data == 0);
 
  if (!MoreArgs(s))
    dump_all = true;
  else
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  if (MoreArgs(s))
  {
    /* More arguments potentially means the user is using the
     * ::command_t :bind command thus we delegate the task. */
    return MUTT_CMD_ERROR;
  }
 
  struct Buffer *filebuf = buf_pool_get();
  if (dump_all || mutt_istr_equal(buf_string(buf), "all"))
  {
    if (bind)
      dump_all_binds(filebuf);
    else
      dump_all_macros(filebuf);
  }
  else
  {
    const int menu_index = mutt_map_get_value(buf_string(buf), MenuNames);
    if (menu_index == -1)
    {
      // L10N: '%s' is the (misspelled) name of the menu, e.g. 'index' or 'pager'
      buf_printf(err, _("%s: no such menu"), buf_string(buf));
      buf_pool_release(&filebuf);
      return MUTT_CMD_ERROR;
    }
 
    if (bind)
      dump_bind(filebuf, menu_index, buf_string(buf));
    else
      dump_macro(filebuf, menu_index, buf_string(buf));
  }
 
  if (buf_is_empty(filebuf))
  {
    // L10N: '%s' is the name of the menu, e.g. 'index' or 'pager',
    //       it might also be 'all' when all menus are affected.
    buf_printf(err, bind ? _("%s: no binds for this menu") : _("%s: no macros for this menu"),
               dump_all ? "all" : buf_string(buf));
    buf_pool_release(&filebuf);
    return MUTT_CMD_ERROR;
  }
 
  struct Buffer *tempfile = buf_pool_get();
  buf_mktemp(tempfile);
  fp_out = mutt_file_fopen(buf_string(tempfile), "w");
  if (!fp_out)
  {
    // L10N: '%s' is the file name of the temporary file
    buf_printf(err, _("Could not create temporary file %s"), buf_string(tempfile));
    buf_pool_release(&filebuf);
    buf_pool_release(&tempfile);
    return MUTT_CMD_ERROR;
  }
  fputs(buf_string(filebuf), fp_out);
 
  mutt_file_fclose(&fp_out);
  buf_pool_release(&filebuf);
 
  struct PagerData pdata = { 0 };
  struct PagerView pview = { &pdata };
 
  pdata.fname = buf_string(tempfile);
 
  pview.banner = (bind) ? "bind" : "macro";
  pview.flags = MUTT_PAGER_NO_FLAGS;
  pview.mode = PAGER_MODE_OTHER;
 
  mutt_do_pager(&pview, NULL);
  buf_pool_release(&tempfile);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_parse_push()

enum CommandResult mutt_parse_push	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 344 of file parse.c.

{
  parse_extract_token(buf, s, TOKEN_CONDENSE);
  if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), "push");
    return MUTT_CMD_ERROR;
  }
 
  generic_tokenize_push_string(buf->data);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_parse_bind()

enum CommandResult mutt_parse_bind	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

bind menu-name <key_sequence> function-name

Definition at line 363 of file parse.c.

{
  if (StartupComplete)
  {
    // Save and restore the offset in `s` because dump_bind_macro() might change it
    char *dptr = s->dptr;
    if (dump_bind_macro(buf, s, data, err) == MUTT_CMD_SUCCESS)
      return MUTT_CMD_SUCCESS;
    if (!buf_is_empty(err))
      return MUTT_CMD_ERROR;
    s->dptr = dptr;
  }
 
  const struct MenuFuncOp *funcs = NULL;
  enum MenuType mtypes[MenuNamesLen];
  int num_menus = 0;
  enum CommandResult rc = MUTT_CMD_SUCCESS;
 
  char *key = parse_keymap(mtypes, s, mutt_array_size(mtypes), &num_menus, err, true);
  if (!key)
    return MUTT_CMD_ERROR;
 
  /* function to execute */
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), "bind");
    rc = MUTT_CMD_ERROR;
  }
  else if (mutt_istr_equal("noop", buf->data))
  {
    for (int i = 0; i < num_menus; i++)
    {
      km_bindkey(key, mtypes[i], OP_NULL); /* the 'unbind' command */
      funcs = km_get_table(mtypes[i]);
      if (funcs)
      {
        char keystr[32] = { 0 };
        km_expand_key_string(key, keystr, sizeof(keystr));
        const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
        mutt_debug(LL_NOTIFY, "NT_BINDING_DELETE: %s %s\n", mname, keystr);
 
        int op = get_op(OpGeneric, buf->data, mutt_str_len(buf->data));
        struct EventBinding ev_b = { mtypes[i], key, op };
        notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_DELETE, &ev_b);
      }
    }
  }
  else
  {
    for (int i = 0; i < num_menus; i++)
    {
      /* The pager and editor menus don't use the generic map,
       * however for other menus try generic first. */
      if ((mtypes[i] != MENU_PAGER) && (mtypes[i] != MENU_EDITOR) && (mtypes[i] != MENU_GENERIC))
      {
        rc = try_bind(key, mtypes[i], buf->data, OpGeneric, err);
        if (rc == MUTT_CMD_SUCCESS)
        {
          char keystr[32] = { 0 };
          km_expand_key_string(key, keystr, sizeof(keystr));
          const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
          mutt_debug(LL_NOTIFY, "NT_BINDING_NEW: %s %s\n", mname, keystr);
 
          int op = get_op(OpGeneric, buf->data, mutt_str_len(buf->data));
          struct EventBinding ev_b = { mtypes[i], key, op };
          notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_ADD, &ev_b);
          continue;
        }
        if (rc == MUTT_CMD_WARNING)
          break;
      }
 
      /* Clear any error message, we're going to try again */
      err->data[0] = '\0';
      funcs = km_get_table(mtypes[i]);
      if (funcs)
      {
        rc = try_bind(key, mtypes[i], buf->data, funcs, err);
        if (rc == MUTT_CMD_SUCCESS)
        {
          char keystr[32] = { 0 };
          km_expand_key_string(key, keystr, sizeof(keystr));
          const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
          mutt_debug(LL_NOTIFY, "NT_BINDING_NEW: %s %s\n", mname, keystr);
 
          int op = get_op(funcs, buf->data, mutt_str_len(buf->data));
          struct EventBinding ev_b = { mtypes[i], key, op };
          notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_ADD, &ev_b);
          continue;
        }
      }
    }
  }
  FREE(&key);
  return rc;
}

Here is the call graph for this function:

mutt_parse_unbind()

enum CommandResult mutt_parse_unbind	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Command unbinds:

• one binding in one menu-name
• one binding in all menu-names
• all bindings in all menu-names

unbind <menu-name[,...]|*> [<key_sequence>]

Definition at line 472 of file parse.c.

{
  bool menu_matches[MENU_MAX] = { 0 };
  bool all_keys = false;
  char *key = NULL;
 
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  if (mutt_str_equal(buf->data, "*"))
  {
    for (enum MenuType i = 1; i < MENU_MAX; i++)
      menu_matches[i] = true;
  }
  else
  {
    parse_menu(menu_matches, buf->data, err);
  }
 
  if (MoreArgs(s))
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    key = buf->data;
  }
  else
  {
    all_keys = true;
  }
 
  if (MoreArgs(s))
  {
    const char *cmd = (data & MUTT_UNMACRO) ? "unmacro" : "unbind";
 
    buf_printf(err, _("%s: too many arguments"), cmd);
    return MUTT_CMD_ERROR;
  }
 
  for (enum MenuType i = 1; i < MENU_MAX; i++)
  {
    if (!menu_matches[i])
      continue;
    if (all_keys)
    {
      km_unbind_all(&Keymaps[i], data);
      km_bindkey("<enter>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
      km_bindkey("<return>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
      km_bindkey("<enter>", MENU_INDEX, OP_DISPLAY_MESSAGE);
      km_bindkey("<return>", MENU_INDEX, OP_DISPLAY_MESSAGE);
      km_bindkey("<backspace>", MENU_EDITOR, OP_EDITOR_BACKSPACE);
      km_bindkey("\177", MENU_EDITOR, OP_EDITOR_BACKSPACE);
      km_bindkey(":", MENU_GENERIC, OP_ENTER_COMMAND);
      km_bindkey(":", MENU_PAGER, OP_ENTER_COMMAND);
      if (i != MENU_EDITOR)
      {
        km_bindkey("?", i, OP_HELP);
        km_bindkey("q", i, OP_EXIT);
      }
 
      const char *mname = mutt_map_get_name(i, MenuNames);
      mutt_debug(LL_NOTIFY, "NT_MACRO_DELETE_ALL: %s\n", mname);
 
      struct EventBinding ev_b = { i, NULL, OP_NULL };
      notify_send(NeoMutt->notify, NT_BINDING,
                  (data & MUTT_UNMACRO) ? NT_MACRO_DELETE_ALL : NT_BINDING_DELETE_ALL,
                  &ev_b);
    }
    else
    {
      char keystr[32] = { 0 };
      km_expand_key_string(key, keystr, sizeof(keystr));
      const char *mname = mutt_map_get_name(i, MenuNames);
      mutt_debug(LL_NOTIFY, "NT_MACRO_DELETE: %s %s\n", mname, keystr);
 
      km_bindkey(key, i, OP_NULL);
      struct EventBinding ev_b = { i, key, OP_NULL };
      notify_send(NeoMutt->notify, NT_BINDING,
                  (data & MUTT_UNMACRO) ? NT_MACRO_DELETE : NT_BINDING_DELETE, &ev_b);
    }
  }
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_parse_macro()

enum CommandResult mutt_parse_macro	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

macro <menu> <key> <macro> <description>

Definition at line 559 of file parse.c.

{
  if (StartupComplete)
  {
    // Save and restore the offset in `s` because dump_bind_macro() might change it
    char *dptr = s->dptr;
    if (dump_bind_macro(buf, s, data, err) == MUTT_CMD_SUCCESS)
      return MUTT_CMD_SUCCESS;
    if (!buf_is_empty(err))
      return MUTT_CMD_ERROR;
    s->dptr = dptr;
  }
 
  enum MenuType mtypes[MenuNamesLen];
  int num_menus = 0;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  char *key = parse_keymap(mtypes, s, mutt_array_size(mtypes), &num_menus, err, false);
  if (!key)
    return MUTT_CMD_ERROR;
 
  parse_extract_token(buf, s, TOKEN_CONDENSE);
  /* make sure the macro sequence is not an empty string */
  if (buf->data[0] == '\0')
  {
    buf_strcpy(err, _("macro: empty key sequence"));
  }
  else
  {
    if (MoreArgs(s))
    {
      char *seq = mutt_str_dup(buf->data);
      parse_extract_token(buf, s, TOKEN_CONDENSE);
 
      if (MoreArgs(s))
      {
        buf_printf(err, _("%s: too many arguments"), "macro");
      }
      else
      {
        for (int i = 0; i < num_menus; i++)
        {
          rc = km_bind(key, mtypes[i], OP_MACRO, seq, buf->data);
          if (rc == MUTT_CMD_SUCCESS)
          {
            char keystr[32] = { 0 };
            km_expand_key_string(key, keystr, sizeof(keystr));
            const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
            mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", mname, keystr);
 
            struct EventBinding ev_b = { mtypes[i], key, OP_MACRO };
            notify_send(NeoMutt->notify, NT_BINDING, NT_MACRO_ADD, &ev_b);
            continue;
          }
        }
      }
 
      FREE(&seq);
    }
    else
    {
      for (int i = 0; i < num_menus; i++)
      {
        rc = km_bind(key, mtypes[i], OP_MACRO, buf->data, NULL);
        if (rc == MUTT_CMD_SUCCESS)
        {
          char keystr[32] = { 0 };
          km_expand_key_string(key, keystr, sizeof(keystr));
          const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
          mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", mname, keystr);
 
          struct EventBinding ev_b = { mtypes[i], key, OP_MACRO };
          notify_send(NeoMutt->notify, NT_BINDING, NT_MACRO_ADD, &ev_b);
          continue;
        }
      }
    }
  }
  FREE(&key);
  return rc;
}

Here is the call graph for this function:

mutt_parse_exec()

enum CommandResult mutt_parse_exec	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 645 of file parse.c.

{
  int ops[128];
  int nops = 0;
  const struct MenuFuncOp *funcs = NULL;
  char *function = NULL;
 
  if (!MoreArgs(s))
  {
    buf_strcpy(err, _("exec: no arguments"));
    return MUTT_CMD_ERROR;
  }
 
  do
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    function = buf->data;
 
    const enum MenuType mtype = menu_get_current_type();
    funcs = km_get_table(mtype);
    if (!funcs && (mtype != MENU_PAGER))
      funcs = OpGeneric;
 
    ops[nops] = get_op(funcs, function, mutt_str_len(function));
    if ((ops[nops] == OP_NULL) && (mtype != MENU_PAGER) && (mtype != MENU_GENERIC))
    {
      ops[nops] = get_op(OpGeneric, function, mutt_str_len(function));
    }
 
    if (ops[nops] == OP_NULL)
    {
      mutt_flushinp();
      mutt_error(_("%s: no such function"), function);
      return MUTT_CMD_ERROR;
    }
    nops++;
  } while (MoreArgs(s) && nops < mutt_array_size(ops));
 
  while (nops)
    mutt_push_macro_event(0, ops[--nops]);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_lua_parse()

enum CommandResult mutt_lua_parse	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 471 of file mutt_lua.c.

{
  lua_init(&LuaState);
  mutt_debug(LL_DEBUG2, " * mutt_lua_parse(%s)\n", buf->data);
 
  if (luaL_dostring(LuaState, s->dptr))
  {
    mutt_debug(LL_DEBUG2, " * %s -> failure\n", s->dptr);
    buf_printf(err, "%s: %s", s->dptr, lua_tostring(LuaState, -1));
    /* pop error message from the stack */
    lua_pop(LuaState, 1);
    return MUTT_CMD_ERROR;
  }
  mutt_debug(LL_DEBUG2, " * %s -> success\n", s->dptr);
  buf_reset(s); // Clear the rest of the line
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_lua_source_file()

enum CommandResult mutt_lua_source_file	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 493 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG2, " * mutt_lua_source()\n");
 
  lua_init(&LuaState);
 
  if (parse_extract_token(buf, s, TOKEN_NO_FLAGS) != 0)
  {
    buf_printf(err, _("source: error at %s"), s->dptr);
    return MUTT_CMD_ERROR;
  }
  if (MoreArgs(s))
  {
    buf_printf(err, _("%s: too many arguments"), "source");
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *path = buf_pool_get();
  buf_copy(path, buf);
  buf_expand_path(path);
 
  if (luaL_dofile(LuaState, buf_string(path)))
  {
    mutt_error(_("Couldn't source lua source: %s"), lua_tostring(LuaState, -1));
    lua_pop(LuaState, 1);
    buf_pool_release(&path);
    return MUTT_CMD_ERROR;
  }
 
  buf_pool_release(&path);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

parse_set()

enum CommandResult parse_set	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

This is used by 'reset', 'set', 'toggle' and 'unset'.

Definition at line 469 of file set.c.

{
  /* The order must match `enum MuttSetCommand` */
  static const char *set_commands[] = { "set", "toggle", "unset", "reset" };
 
  if (!buf || !s)
    return MUTT_CMD_ERROR;
 
  do
  {
    bool prefix = false;
    bool query = false;
    bool inv = (data == MUTT_SET_INV);
    bool reset = (data == MUTT_SET_RESET);
    bool unset = (data == MUTT_SET_UNSET);
 
    if (*s->dptr == '?')
    {
      prefix = true;
      query = true;
      s->dptr++;
    }
    else if (mutt_str_startswith(s->dptr, "no"))
    {
      prefix = true;
      unset = !unset;
      s->dptr += 2;
    }
    else if (mutt_str_startswith(s->dptr, "inv"))
    {
      prefix = true;
      inv = !inv;
      s->dptr += 3;
    }
    else if (*s->dptr == '&')
    {
      prefix = true;
      reset = true;
      s->dptr++;
    }
 
    if (prefix && (data != MUTT_SET_SET))
    {
      buf_printf(err, _("Can't use 'inv', 'no', '&' or '?' with the '%s' command"),
                 set_commands[data]);
      return MUTT_CMD_WARNING;
    }
 
    // get the variable name.  Note that buf might be empty if no additional
    // argument was given.
    int ret = parse_extract_token(buf, s, TOKEN_EQUAL | TOKEN_QUESTION | TOKEN_PLUS | TOKEN_MINUS);
    if (ret == -1)
      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->data);
    if (he)
    {
      // Use the correct name if a synonym is used
      buf_strcpy(buf, he->key.strkey);
      bool_or_quad = ((DTYPE(he->type) == DT_BOOL) || (DTYPE(he->type) == DT_QUAD));
      invertible = (bool_or_quad || (DTYPE(he->type) == DT_NUMBER));
    }
 
    if (*s->dptr == '?')
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use a prefix when querying a variable"));
        return MUTT_CMD_WARNING;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't query option with the '%s' command"), set_commands[data]);
        return MUTT_CMD_WARNING;
      }
 
      query = true;
      s->dptr++;
    }
    else if ((*s->dptr == '+') || (*s->dptr == '-'))
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use prefix when incrementing or decrementing a variable"));
        return MUTT_CMD_WARNING;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't set option with the '%s' command"), set_commands[data]);
        return MUTT_CMD_WARNING;
      }
      if (*s->dptr == '+')
        increment = true;
      else
        decrement = true;
 
      s->dptr++;
      if (*s->dptr == '=')
      {
        equals = true;
        s->dptr++;
      }
      else
      {
        buf_printf(err, _("'+' and '-' must be followed by '='"));
        return MUTT_CMD_WARNING;
      }
    }
    else if (*s->dptr == '=')
    {
      if (prefix)
      {
        buf_printf(err, _("Can't use prefix when setting a variable"));
        return MUTT_CMD_WARNING;
      }
 
      if (reset || unset || inv)
      {
        buf_printf(err, _("Can't set option with the '%s' command"), set_commands[data]);
        return MUTT_CMD_WARNING;
      }
 
      equals = true;
      s->dptr++;
    }
 
    if (!invertible && (inv || (unset && prefix)))
    {
      if (data == MUTT_SET_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"),
                   set_commands[data]);
      }
      return MUTT_CMD_WARNING;
    }
 
    // 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
 
    enum CommandResult rc = MUTT_CMD_ERROR;
    if (query)
    {
      rc = command_set_query(buf, err);
      return rc; // We can only do one query even if multiple config names are given
    }
    else if (reset)
    {
      rc = command_set_reset(buf, err);
    }
    else if (unset)
    {
      rc = command_set_unset(buf, err);
    }
    else if (inv)
    {
      rc = command_set_toggle(buf, 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, s, TOKEN_BACKTICK_VARS);
      if (increment)
        rc = command_set_increment(buf, value, err);
      else if (decrement)
        rc = command_set_decrement(buf, value, err);
      else
        rc = command_set_set(buf, 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(buf, yes, err);
        buf_pool_release(&yes);
      }
      else
      {
        rc = command_set_query(buf, err);
        return rc; // 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)
      return rc;
  } while (MoreArgs(s));
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_parse_score()

enum CommandResult mutt_parse_score	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 91 of file score.c.

{
  struct Score *ptr = NULL, *last = NULL;
  char *pattern = NULL, *pc = NULL;
 
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "score");
    return MUTT_CMD_WARNING;
  }
  pattern = buf_strdup(buf);
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  if (MoreArgs(s))
  {
    FREE(&pattern);
    buf_printf(err, _("%s: too many arguments"), "score");
    return MUTT_CMD_WARNING;
  }
 
  /* look for an existing entry and update the value, else add it to the end
   * of the list */
  for (ptr = ScoreList, last = NULL; ptr; last = ptr, ptr = ptr->next)
    if (mutt_str_equal(pattern, ptr->str))
      break;
 
  if (ptr)
  {
    /* 'buf' 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 Menu *menu = get_current_menu();
    struct PatternList *pat = mutt_pattern_comp(mv_cur, menu, pattern, MUTT_PC_NO_FLAGS, err);
    if (!pat)
    {
      FREE(&pattern);
      return MUTT_CMD_ERROR;
    }
    ptr = MUTT_MEM_CALLOC(1, struct Score);
    if (last)
      last->next = ptr;
    else
      ScoreList = ptr;
    ptr->pat = pat;
    ptr->str = pattern;
  }
  pc = buf->data;
  if (*pc == '=')
  {
    ptr->exact = true;
    pc++;
  }
  if (!mutt_str_atoi_full(pc, &ptr->val))
  {
    FREE(&pattern);
    buf_strcpy(err, _("Error: score: invalid number"));
    return MUTT_CMD_ERROR;
  }
  OptNeedRescore = true;
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

mutt_parse_unscore()

enum CommandResult mutt_parse_unscore	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 201 of file score.c.

{
  struct Score *tmp = NULL, *last = NULL;
 
  while (MoreArgs(s))
  {
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
    if (mutt_str_equal("*", buf->data))
    {
      for (tmp = ScoreList; tmp;)
      {
        last = tmp;
        tmp = tmp->next;
        mutt_pattern_free(&last->pat);
        FREE(&last);
      }
      ScoreList = NULL;
    }
    else
    {
      for (tmp = ScoreList; tmp; last = tmp, tmp = tmp->next)
      {
        if (mutt_str_equal(buf->data, tmp->str))
        {
          if (last)
            last->next = tmp->next;
          else
            ScoreList = 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;
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

sb_parse_sidebar_pin()

enum CommandResult sb_parse_sidebar_pin	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 41 of file commands.c.

{
  struct Buffer *path = buf_pool_get();
 
  do
  {
    parse_extract_token(path, s, TOKEN_BACKTICK_VARS);
    buf_expand_path(path);
    add_to_stailq(&SidebarPinned, buf_string(path));
  } while (MoreArgs(s));
  buf_pool_release(&path);
 
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sb_parse_sidebar_unpin()

enum CommandResult sb_parse_sidebar_unpin	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 60 of file commands.c.

{
  struct Buffer *path = buf_pool_get();
 
  do
  {
    parse_extract_token(path, s, TOKEN_BACKTICK_VARS);
    /* Check for deletion of entire list */
    if (mutt_str_equal(buf_string(path), "*"))
    {
      mutt_list_free(&SidebarPinned);
      break;
    }
    buf_expand_path(path);
    remove_from_stailq(&SidebarPinned, buf_string(path));
  } while (MoreArgs(s));
  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_unreplace_list()

static enum CommandResult parse_unreplace_list ( struct Buffer *  buf, struct Buffer *  s, struct ReplaceList *  list, struct Buffer *  err  )

static

Remove a string replacement rule - Implements Command::parse() -.

Definition at line 67 of file subjectrx.c.

{
  /* First token is a regex. */
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "unsubjectrx");
    return MUTT_CMD_WARNING;
  }
 
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  /* "*" is a special case. */
  if (mutt_str_equal(buf->data, "*"))
  {
    mutt_replacelist_free(list);
    return MUTT_CMD_SUCCESS;
  }
 
  mutt_replacelist_remove(list, buf->data);
  return MUTT_CMD_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_replace_list()

static enum CommandResult parse_replace_list ( struct Buffer *  buf, struct Buffer *  s, struct ReplaceList *  list, struct Buffer *  err  )

static

Parse a string replacement rule - Implements Command::parse() -.

Definition at line 93 of file subjectrx.c.

{
  struct Buffer *templ = buf_pool_get();
  int rc = MUTT_CMD_WARNING;
 
  /* First token is a regex. */
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "subjectrx");
    goto done;
  }
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
  /* Second token is a replacement template */
  if (!MoreArgs(s))
  {
    buf_printf(err, _("%s: too few arguments"), "subjectrx");
    goto done;
  }
  parse_extract_token(templ, s, TOKEN_NO_FLAGS);
 
  if (mutt_replacelist_add(list, buf->data, buf_string(templ), err) != 0)
  {
    rc = MUTT_CMD_ERROR;
    goto done;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&templ);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_subjectrx_list()

enum CommandResult parse_subjectrx_list	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 171 of file subjectrx.c.

{
  enum CommandResult rc;
 
  rc = parse_replace_list(buf, s, &SubjectRegexList, err);
  if (rc == MUTT_CMD_SUCCESS)
  {
    mutt_debug(LL_NOTIFY, "NT_SUBJRX_ADD: %s\n", buf->data);
    notify_send(SubjRxNotify, NT_SUBJRX, NT_SUBJRX_ADD, NULL);
  }
  return rc;
}

Here is the call graph for this function:

parse_unsubjectrx_list()

enum CommandResult parse_unsubjectrx_list	(	struct Buffer *	buf,
		struct Buffer *	s,
		intptr_t	data,
		struct Buffer *	err
	)

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

Definition at line 188 of file subjectrx.c.

{
  enum CommandResult rc;
 
  rc = parse_unreplace_list(buf, s, &SubjectRegexList, err);
  if (rc == MUTT_CMD_SUCCESS)
  {
    mutt_debug(LL_NOTIFY, "NT_SUBJRX_DELETE: %s\n", buf->data);
    notify_send(SubjRxNotify, NT_SUBJRX, NT_SUBJRX_DELETE, NULL);
  }
  return rc;
}

Here is the call graph for this function: