commands.h File Reference

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

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include "config/lib.h"
#include "core/lib.h"

Include dependency graph for commands.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	MUTT_NAMED   (1 << 0)

Functions
enum CommandResult	parse_mailboxes (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'mailboxes' command - Implements Command::parse() -.
enum CommandResult	parse_my_hdr (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'my_hdr' command - Implements Command::parse() -.
enum CommandResult	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_subscribe_to (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'subscribe-to' 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_unmailboxes (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unmailboxes' 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() -.
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() -.
enum CommandResult	parse_rc_line_cwd (const char *line, char *cwd, struct Buffer *err)
	Parse and run a muttrc line in a relative directory.
char *	mutt_get_sourced_cwd (void)
	Get the current file path that is being parsed.
bool	mailbox_add_simple (const char *mailbox, struct Buffer *err)
	Add a new Mailbox.
int	parse_grouplist (struct GroupList *gl, struct Buffer *buf, struct Buffer *s, struct Buffer *err)
	Parse a group context.
void	source_stack_cleanup (void)
	Free memory from the stack used for the source command.
int	source_rc (const char *rcfile_path, struct Buffer *err)
	Read an initialization file.
enum CommandResult	set_dump (enum GetElemListFlags flags, struct Buffer *err)
	Dump list of config variables into a file/pager.

Detailed Description

Functions to parse commands in a config file.

Authors

• Richard Russon

Copyright

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

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file commands.h.

Macro Definition Documentation

MUTT_NAMED

#define MUTT_NAMED   (1 << 0)

Definition at line 36 of file commands.h.

Function Documentation

parse_rc_line_cwd()

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

Parse and run a muttrc line in a relative directory.

Parameters

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

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 178 of file commands.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_sourced_cwd()

char * mutt_get_sourced_cwd

(

void

)

Get the current file path that is being parsed.

Return values

ptr	File path that is being parsed or cwd at runtime

Note

Caller is responsible for freeing returned string

Definition at line 198 of file commands.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

mailbox_add_simple()

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

Add a new Mailbox.

Parameters

mailbox	Mailbox to add
err	Buffer for error messages

Return values

true

Success

Definition at line 741 of file commands.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

parse_grouplist()

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

Parse a group context.

Parameters

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

Return values

0	Success
-1	Error

Definition at line 144 of file commands.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

source_stack_cleanup()

void source_stack_cleanup

(

void

)

Free memory from the stack used for the source command.

Definition at line 1671 of file commands.c.

{
  mutt_list_free(&MuttrcStack);
}

Here is the call graph for this function:

Here is the caller graph for this function:

source_rc()

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

Read an initialization file.

Parameters

rcfile_path	Path to initialization file
err	Buffer for error messages

Return values

<0	NeoMutt should pause to let the user know

Definition at line 219 of file commands.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

set_dump()

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

Dump list of config variables into a file/pager.

Parameters

flags	Which config to dump, e.g. GEL_CHANGED_CONFIG
err	Buffer for error message

Returns

num See CommandResult

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

Definition at line 888 of file commands.c.

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

Here is the call graph for this function:

Here is the caller graph for this function: