NeoMutt  2020-03-20-65-g141838
Teaching an old dog new tricks
DOXYGEN
icommands.c File Reference

Information commands. More...

#include "config.h"
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "icommands.h"
#include "functions.h"
#include "init.h"
#include "keymap.h"
#include "muttlib.h"
#include "opcodes.h"
#include "pager.h"
#include "version.h"
+ Include dependency graph for icommands.c:

Go to the source code of this file.

Functions

static enum CommandResult icmd_bind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse 'bind' and 'macro' commands - Implements ICommand::parse() More...
 
static enum CommandResult icmd_set (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse 'set' command to display config - Implements ICommand::parse() More...
 
static enum CommandResult icmd_version (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse 'version' command - Implements ICommand::parse() More...
 
enum CommandResult mutt_parse_icommand (char *line, struct Buffer *err)
 Parse an informational command. More...
 
static void dump_bind (struct Buffer *buf, struct Mapping *menu, struct Keymap *map)
 Dump a bind map to a buffer. More...
 
static void dump_macro (struct Buffer *buf, struct Mapping *menu, struct Keymap *map)
 Dump a macro map to a buffer. More...
 
static bool dump_menu (struct Buffer *buf, struct Mapping *menu, bool bind)
 Dumps all the binds or macros maps of a menu into a buffer. More...
 
static void dump_all_menus (struct Buffer *buf, bool bind)
 Dumps all the binds or macros inside every menu. More...
 

Variables

const struct ICommand ICommandList []
 All available informational commands. More...
 

Detailed Description

Information commands.

Authors
  • Christopher John Czettel
  • Richard Russon
  • Victor Fernandes

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 icommands.c.

Function Documentation

◆ icmd_bind()

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

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

Definition at line 231 of file icommands.c.

233 {
234  FILE *fp_out = NULL;
235  char tempfile[PATH_MAX];
236  bool dump_all = false, bind = (data == 0);
237 
238  if (!MoreArgs(s))
239  dump_all = true;
240  else
242 
243  if (MoreArgs(s))
244  {
245  /* More arguments potentially means the user is using the
246  * ::command_t :bind command thus we delegate the task. */
247  return MUTT_CMD_ERROR;
248  }
249 
250  struct Buffer filebuf = mutt_buffer_make(4096);
251  if (dump_all || (mutt_str_strcasecmp(buf->data, "all") == 0))
252  {
253  dump_all_menus(&filebuf, bind);
254  }
255  else
256  {
257  const int menu_index = mutt_map_get_value(buf->data, Menus);
258  if (menu_index == -1)
259  {
260  // L10N: '%s' is the (misspelled) name of the menu, e.g. 'index' or 'pager'
261  mutt_buffer_printf(err, _("%s: no such menu"), buf->data);
262  mutt_buffer_dealloc(&filebuf);
263  return MUTT_CMD_ERROR;
264  }
265 
266  struct Mapping menu = { buf->data, menu_index };
267  dump_menu(&filebuf, &menu, bind);
268  }
269 
270  if (mutt_buffer_is_empty(&filebuf))
271  {
272  // L10N: '%s' is the name of the menu, e.g. 'index' or 'pager', it might
273  // L10N: also be 'all' when all menus are affected.
274  mutt_buffer_printf(err, bind ? _("%s: no binds for this menu") : _("%s: no macros for this menu"),
275  dump_all ? "all" : buf->data);
276  mutt_buffer_dealloc(&filebuf);
277  return MUTT_CMD_ERROR;
278  }
279 
280  mutt_mktemp(tempfile, sizeof(tempfile));
281  fp_out = mutt_file_fopen(tempfile, "w");
282  if (!fp_out)
283  {
284  // L10N: '%s' is the file name of the temporary file
285  mutt_buffer_printf(err, _("Could not create temporary file %s"), tempfile);
286  mutt_buffer_dealloc(&filebuf);
287  return MUTT_CMD_ERROR;
288  }
289  fputs(filebuf.data, fp_out);
290 
291  mutt_file_fclose(&fp_out);
292  mutt_buffer_dealloc(&filebuf);
293 
294  if (mutt_do_pager((bind) ? "bind" : "macro", tempfile, MUTT_PAGER_NO_FLAGS, NULL) == -1)
295  {
296  // L10N: '%s' is the file name of the temporary file
297  mutt_buffer_printf(err, _("Could not create temporary file %s"), tempfile);
298  return MUTT_CMD_ERROR;
299  }
300 
301  return MUTT_CMD_SUCCESS;
302 }
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
#define _(a)
Definition: message.h:28
static bool dump_menu(struct Buffer *buf, struct Mapping *menu, bool bind)
Dumps all the binds or macros maps of a menu into a buffer.
Definition: icommands.c:184
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
#define MoreArgs(buf)
Definition: buffer.h:43
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
static void dump_all_menus(struct Buffer *buf, bool bind)
Dumps all the binds or macros inside every menu.
Definition: icommands.c:213
const struct Mapping Menus[]
Menu name lookup table.
Definition: keymap.c:61
#define mutt_mktemp(buf, buflen)
Definition: muttlib.h:78
#define PATH_MAX
Definition: mutt.h:44
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: init.c:416
char * data
Pointer to data.
Definition: buffer.h:35
Success: Command worked.
Definition: mutt_commands.h:37
int mutt_do_pager(const char *banner, const char *tempfile, PagerFlags do_color, struct Pager *info)
Display some page-able text to the user.
Definition: curs_lib.c:666
int mutt_str_strcasecmp(const char *a, const char *b)
Compare two strings ignoring case, safely.
Definition: string.c:651
Mapping between user-readable string and a constant.
Definition: mapping.h:29
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588
bool mutt_buffer_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:252
#define MUTT_PAGER_NO_FLAGS
No flags are set.
Definition: pager.h:43
#define MUTT_TOKEN_NO_FLAGS
No flags are set.
Definition: mutt.h:70
int mutt_map_get_value(const char *name, const struct Mapping *map)
Lookup the constant for a string.
Definition: mapping.c:85
+ Here is the call graph for this function:

◆ icmd_set()

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

Parse 'set' command to display config - Implements ICommand::parse()

Definition at line 307 of file icommands.c.

309 {
310  char tempfile[PATH_MAX];
311  mutt_mktemp(tempfile, sizeof(tempfile));
312 
313  FILE *fp_out = mutt_file_fopen(tempfile, "w");
314  if (!fp_out)
315  {
316  // L10N: '%s' is the file name of the temporary file
317  mutt_buffer_printf(err, _("Could not create temporary file %s"), tempfile);
318  return MUTT_CMD_ERROR;
319  }
320 
321  if (mutt_str_strcmp(s->data, "set all") == 0)
322  {
324  }
325  else if (mutt_str_strcmp(s->data, "set") == 0)
326  {
328  }
329  else
330  {
331  mutt_file_fclose(&fp_out);
332  return MUTT_CMD_ERROR;
333  }
334 
335  mutt_file_fclose(&fp_out);
336 
337  if (mutt_do_pager("set", tempfile, MUTT_PAGER_NO_FLAGS, NULL) == -1)
338  {
339  // L10N: '%s' is the file name of the temporary file
340  mutt_buffer_printf(err, _("Could not create temporary file %s"), tempfile);
341  return MUTT_CMD_ERROR;
342  }
343 
344  return MUTT_CMD_SUCCESS;
345 }
#define CS_DUMP_ONLY_CHANGED
Only show config that the user has changed.
Definition: dump.h:36
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
#define _(a)
Definition: message.h:28
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
Container for Accounts, Notifications.
Definition: neomutt.h:35
struct ConfigSet * cs
Parent ConfigSet.
Definition: subset.h:51
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
#define mutt_mktemp(buf, buflen)
Definition: muttlib.h:78
#define PATH_MAX
Definition: mutt.h:44
#define CS_DUMP_NO_FLAGS
No flags are set.
Definition: dump.h:35
char * data
Pointer to data.
Definition: buffer.h:35
bool dump_config(struct ConfigSet *cs, ConfigDumpFlags flags, FILE *fp)
Write all the config to a file.
Definition: dump.c:154
Success: Command worked.
Definition: mutt_commands.h:37
int mutt_do_pager(const char *banner, const char *tempfile, PagerFlags do_color, struct Pager *info)
Display some page-able text to the user.
Definition: curs_lib.c:666
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:38
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:638
#define MUTT_PAGER_NO_FLAGS
No flags are set.
Definition: pager.h:43
+ Here is the call graph for this function:

◆ icmd_version()

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

Parse 'version' command - Implements ICommand::parse()

Definition at line 350 of file icommands.c.

352 {
353  char tempfile[PATH_MAX];
354  mutt_mktemp(tempfile, sizeof(tempfile));
355 
356  FILE *fp_out = mutt_file_fopen(tempfile, "w");
357  if (!fp_out)
358  {
359  // L10N: '%s' is the file name of the temporary file
360  mutt_buffer_printf(err, _("Could not create temporary file %s"), tempfile);
361  return MUTT_CMD_ERROR;
362  }
363 
364  print_version(fp_out);
365  mutt_file_fclose(&fp_out);
366 
367  if (mutt_do_pager("version", tempfile, MUTT_PAGER_NO_FLAGS, NULL) == -1)
368  {
369  // L10N: '%s' is the file name of the temporary file
370  mutt_buffer_printf(err, _("Could not create temporary file %s"), tempfile);
371  return MUTT_CMD_ERROR;
372  }
373 
374  return MUTT_CMD_SUCCESS;
375 }
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
void print_version(FILE *fp)
Print system and compile info to a file.
Definition: version.c:429
#define _(a)
Definition: message.h:28
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
#define mutt_mktemp(buf, buflen)
Definition: muttlib.h:78
#define PATH_MAX
Definition: mutt.h:44
Success: Command worked.
Definition: mutt_commands.h:37
int mutt_do_pager(const char *banner, const char *tempfile, PagerFlags do_color, struct Pager *info)
Display some page-able text to the user.
Definition: curs_lib.c:666
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588
#define MUTT_PAGER_NO_FLAGS
No flags are set.
Definition: pager.h:43
+ Here is the call graph for this function:

◆ mutt_parse_icommand()

enum CommandResult mutt_parse_icommand ( char *  line,
struct Buffer err 
)

Parse an informational command.

Parameters
lineCommand to execute
errBuffer for error messages
Return values
MUTT_CMD_SUCCESSSuccess
MUTT_CMD_ERRORError (no message): command not found
MUTT_CMD_ERRORError with message: command failed
MUTT_CMD_WARNINGWarning with message: command failed

Definition at line 77 of file icommands.c.

78 {
79  if (!line || !*line || !err)
80  return MUTT_CMD_ERROR;
81 
82  enum CommandResult rc = MUTT_CMD_ERROR;
83 
84  struct Buffer *token = mutt_buffer_pool_get();
85  struct Buffer expn = mutt_buffer_make(0);
86  mutt_buffer_addstr(&expn, line);
87  expn.dptr = expn.data;
88 
89  mutt_buffer_reset(err);
90 
91  SKIPWS(expn.dptr);
93  for (size_t i = 0; ICommandList[i].name; i++)
94  {
95  if (mutt_str_strcmp(token->data, ICommandList[i].name) != 0)
96  continue;
97 
98  rc = ICommandList[i].parse(token, &expn, ICommandList[i].data, err);
99  if (rc != 0)
100  goto finish;
101 
102  break; /* Continue with next command */
103  }
104 
105 finish:
106  mutt_buffer_pool_release(&token);
107  mutt_buffer_dealloc(&expn);
108  return rc;
109 }
void mutt_buffer_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:79
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
CommandResult
Error codes for command_t parse functions.
Definition: mutt_commands.h:33
Error: Can&#39;t help the user.
Definition: mutt_commands.h:35
char * name
Name of the command.
Definition: icommands.h:36
const struct ICommand ICommandList[]
All available informational commands.
Definition: icommands.c:59
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
#define SKIPWS(ch)
Definition: string2.h:47
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
size_t mutt_buffer_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:225
enum CommandResult(* parse)(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Function to parse information commands.
Definition: icommands.h:46
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: init.c:416
char * dptr
Current read/write position.
Definition: buffer.h:36
char * data
Pointer to data.
Definition: buffer.h:35
int const char int line
Definition: acutest.h:602
int mutt_str_strcmp(const char *a, const char *b)
Compare two strings, safely.
Definition: string.c:638
#define MUTT_TOKEN_NO_FLAGS
No flags are set.
Definition: mutt.h:70
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_bind()

static void dump_bind ( struct Buffer buf,
struct Mapping menu,
struct Keymap map 
)
static

Dump a bind map to a buffer.

Parameters
bufOutput buffer
menuMap menu
mapBind keymap

Definition at line 117 of file icommands.c.

118 {
119  char key_binding[32];
120  const char *fn_name = NULL;
121 
122  km_expand_key(key_binding, sizeof(key_binding), map);
123  if (map->op == OP_NULL)
124  {
125  mutt_buffer_add_printf(buf, "bind %s %s noop\n", menu->name, key_binding);
126  return;
127  }
128 
129  /* The pager and editor menus don't use the generic map,
130  * however for other menus try generic first. */
131  if ((menu->value != MENU_PAGER) && (menu->value != MENU_EDITOR) && (menu->value != MENU_GENERIC))
132  {
133  fn_name = mutt_get_func(OpGeneric, map->op);
134  }
135 
136  /* if it's one of the menus above or generic doesn't find
137  * the function, try with its own menu. */
138  if (!fn_name)
139  {
140  const struct Binding *bindings = km_get_table(menu->value);
141  if (!bindings)
142  return;
143 
144  fn_name = mutt_get_func(bindings, map->op);
145  }
146 
147  mutt_buffer_add_printf(buf, "bind %s %s %s\n", menu->name, key_binding, fn_name);
148 }
int value
Definition: mapping.h:32
Pager pager (email viewer)
Definition: keymap.h:78
const char * mutt_get_func(const struct Binding *bindings, int op)
Get the name of a function.
Definition: keymap.c:501
const struct Binding OpGeneric[]
Key bindings for the generic menu.
Definition: functions.c:55
short op
operation to perform
Definition: keymap.h:51
int mutt_buffer_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:203
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: keymap.c:870
const struct Binding * km_get_table(enum MenuType menu)
Lookup a menu&#39;s keybindings.
Definition: keymap.c:1264
Text entry area.
Definition: keymap.h:74
const char * name
Definition: mapping.h:31
Mapping between a user key and a function.
Definition: keymap.h:117
Generic selection list.
Definition: keymap.h:76
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_macro()

static void dump_macro ( struct Buffer buf,
struct Mapping menu,
struct Keymap map 
)
static

Dump a macro map to a buffer.

Parameters
bufOutput buffer
menuMap menu
mapMacro keymap

Definition at line 156 of file icommands.c.

157 {
158  char key_binding[MAX_SEQ];
159  km_expand_key(key_binding, MAX_SEQ, map);
160 
161  struct Buffer tmp = mutt_buffer_make(0);
162  escape_string(&tmp, map->macro);
163 
164  if (map->desc)
165  {
166  mutt_buffer_add_printf(buf, "macro %s %s \"%s\" \"%s\"\n", menu->name,
167  key_binding, tmp.data, map->desc);
168  }
169  else
170  {
171  mutt_buffer_add_printf(buf, "macro %s %s \"%s\"\n", menu->name, key_binding, tmp.data);
172  }
173 
174  mutt_buffer_dealloc(&tmp);
175 }
struct Buffer mutt_buffer_make(size_t size)
Make a new buffer on the stack.
Definition: buffer.c:61
String manipulation buffer.
Definition: buffer.h:33
void mutt_buffer_dealloc(struct Buffer *buf)
Release the memory allocated by a buffer.
Definition: buffer.c:294
int mutt_buffer_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:203
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: keymap.c:870
char * macro
macro expansion (op == OP_MACRO)
Definition: keymap.h:48
char * data
Pointer to data.
Definition: buffer.h:35
char * desc
description of a macro for the help menu
Definition: keymap.h:49
#define MAX_SEQ
Definition: keymap.h:34
size_t escape_string(struct Buffer *buf, const char *src)
Write a string to a buffer, escaping special characters.
Definition: dump.c:46
const char * name
Definition: mapping.h:31
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_menu()

static bool dump_menu ( struct Buffer buf,
struct Mapping menu,
bool  bind 
)
static

Dumps all the binds or macros maps of a menu into a buffer.

Parameters
bufOutput buffer
menuMenu to dump
bindIf true it's :bind, else :macro
Return values
booltrue if menu is empty, false if not

Definition at line 184 of file icommands.c.

185 {
186  bool empty = true;
187  struct Keymap *map = NULL, *next = NULL;
188 
189  for (map = Keymaps[menu->value]; map; map = next)
190  {
191  next = map->next;
192 
193  if (bind && (map->op != OP_MACRO))
194  {
195  empty = false;
196  dump_bind(buf, menu, map);
197  }
198  else if (!bind && (map->op == OP_MACRO))
199  {
200  empty = false;
201  dump_macro(buf, menu, map);
202  }
203  }
204 
205  return empty;
206 }
struct Keymap * Keymaps[MENU_MAX]
Array of Keymap keybindings, one for each Menu.
Definition: keymap.c:149
static void dump_bind(struct Buffer *buf, struct Mapping *menu, struct Keymap *map)
Dump a bind map to a buffer.
Definition: icommands.c:117
int value
Definition: mapping.h:32
short op
operation to perform
Definition: keymap.h:51
struct Keymap * next
next key in map
Definition: keymap.h:50
A keyboard mapping.
Definition: keymap.h:46
static void dump_macro(struct Buffer *buf, struct Mapping *menu, struct Keymap *map)
Dump a macro map to a buffer.
Definition: icommands.c:156
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dump_all_menus()

static void dump_all_menus ( struct Buffer buf,
bool  bind 
)
static

Dumps all the binds or macros inside every menu.

Parameters
bufOutput buffer
bindIf true it's :bind, else :macro

Definition at line 213 of file icommands.c.

214 {
215  for (int i = 0; i < MENU_MAX; i++)
216  {
217  const char *menu_name = mutt_map_get_name(i, Menus);
218  struct Mapping menu = { menu_name, i };
219 
220  const bool empty = dump_menu(buf, &menu, bind);
221 
222  /* Add a new line for readability between menus. */
223  if (!empty && (i < (MENU_MAX - 1)))
224  mutt_buffer_addch(buf, '\n');
225  }
226 }
static bool dump_menu(struct Buffer *buf, struct Mapping *menu, bool bind)
Dumps all the binds or macros maps of a menu into a buffer.
Definition: icommands.c:184
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
const struct Mapping Menus[]
Menu name lookup table.
Definition: keymap.c:61
size_t mutt_buffer_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:240
Mapping between user-readable string and a constant.
Definition: mapping.h:29
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ ICommandList

const struct ICommand ICommandList[]
Initial value:
= {
{ "bind", icmd_bind, 0 },
{ "macro", icmd_bind, 1 },
{ "set", icmd_set, 0 },
{ "version", icmd_version, 0 },
{ NULL, NULL, 0 },
}
static enum CommandResult icmd_version(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse &#39;version&#39; command - Implements ICommand::parse()
Definition: icommands.c:350
static enum CommandResult icmd_set(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse &#39;set&#39; command to display config - Implements ICommand::parse()
Definition: icommands.c:307
static enum CommandResult icmd_bind(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse &#39;bind&#39; and &#39;macro&#39; commands - Implements ICommand::parse()
Definition: icommands.c:231

All available informational commands.

Note
These commands take precedence over conventional NeoMutt rc-lines

Definition at line 59 of file icommands.c.