commands.c File Reference

Parse key binding commands. More...

#include "config.h"
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "lib.h"
#include "menu/lib.h"
#include "parse/lib.h"

Include dependency graph for commands.c:

Go to the source code of this file.

Macros
#define	MAX_SEQ   8
	Maximum length of a key binding sequence used for buffer in km_bind.

Functions
enum CommandResult	km_bind (const char *s, enum MenuType mtype, int op, char *macro, char *desc, struct Buffer *err)
	Set up a key binding.
static void	km_unbind_all (struct KeymapList *km_list, unsigned long mode)
	Free all the keys in the supplied Keymap.
static char *	parse_keymap (enum MenuType *mtypes, struct Buffer *s, int max_menus, int *num_menus, struct Buffer *err, bool bind)
	Parse a user-config key binding.
static void *	parse_menu (bool *menus, char *s, struct Buffer *err)
	Parse menu-names into an array.
static enum CommandResult	try_bind (char *key, enum MenuType mtype, char *func, const struct MenuFuncOp *funcs, struct Buffer *err)
	Try to make a key binding.
enum CommandResult	parse_push (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'push' command - Implements Command::parse() -.
enum CommandResult	parse_bind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'bind' command - Implements Command::parse() -.
enum CommandResult	parse_unbind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unbind' command - Implements Command::parse() -.
enum CommandResult	parse_macro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'macro' command - Implements Command::parse() -.
enum CommandResult	parse_exec (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'exec' command - Implements Command::parse() -.

Detailed Description

Parse key binding commands.

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

Macro Definition Documentation

MAX_SEQ

#define MAX_SEQ   8

Maximum length of a key binding sequence used for buffer in km_bind.

Definition at line 43 of file commands.c.

Function Documentation

km_bind()

enum CommandResult km_bind	(	const char *	s,
		enum MenuType	mtype,
		int	op,
		char *	macro,
		char *	desc,
		struct Buffer *	err )

Set up a key binding.

Parameters

s	Key string
mtype	Menu type, e.g. MENU_EDITOR
op	Operation, e.g. OP_DELETE
macro	Macro string
desc	Description of macro (OPTIONAL)
err	Buffer for error message

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Insert a key sequence into the specified map. The map is sorted by ASCII value (lowest to highest)

Definition at line 58 of file commands.c.

{
  enum CommandResult rc = MUTT_CMD_SUCCESS;
  struct Keymap *last = NULL, *np = NULL, *compare = NULL;
  keycode_t buf[MAX_SEQ];
  size_t pos = 0, lastpos = 0;
 
  size_t len = parsekeys(s, buf, MAX_SEQ);
 
  struct Keymap *map = alloc_keys(len, buf);
  map->op = op;
  map->macro = mutt_str_dup(macro);
  map->desc = mutt_str_dup(desc);
 
  /* find position to place new keymap */
  STAILQ_FOREACH(np, &Keymaps[mtype], entries)
  {
    compare = km_compare_keys(map, np, &pos);
 
    if (compare == map) /* map's keycode is bigger */
    {
      last = np;
      lastpos = pos;
      if (pos > np->eq)
        pos = np->eq;
    }
    else if (compare == np) /* np's keycode is bigger, found insert location */
    {
      map->eq = pos;
      break;
    }
    else /* equal keycodes */
    {
      /* Don't warn on overwriting a 'noop' binding */
      if ((np->len != len) && (np->op != OP_NULL))
      {
        static const char *guide_link = "https://neomutt.org/guide/configuration.html#bind-warnings";
        /* Overwrite with the different lengths, warn */
        struct Buffer *old_binding = buf_pool_get();
        struct Buffer *new_binding = buf_pool_get();
 
        km_expand_key(map, old_binding);
        km_expand_key(np, new_binding);
 
        char *err_msg = _("Binding '%s' will alias '%s'  Before, try: 'bind %s %s noop'");
        if (err)
        {
          /* err was passed, put the string there */
          buf_printf(err, err_msg, buf_string(old_binding), buf_string(new_binding),
                     mutt_map_get_name(mtype, MenuNames), buf_string(new_binding));
          buf_add_printf(err, "  %s", guide_link);
        }
        else
        {
          struct Buffer *tmp = buf_pool_get();
          buf_printf(tmp, err_msg, buf_string(old_binding), buf_string(new_binding),
                     mutt_map_get_name(mtype, MenuNames), buf_string(new_binding));
          buf_add_printf(tmp, "  %s", guide_link);
          mutt_error("%s", buf_string(tmp));
          buf_pool_release(&tmp);
        }
        rc = MUTT_CMD_WARNING;
 
        buf_pool_release(&old_binding);
        buf_pool_release(&new_binding);
      }
 
      map->eq = np->eq;
      STAILQ_REMOVE(&Keymaps[mtype], np, Keymap, entries);
      mutt_keymap_free(&np);
      break;
    }
  }
 
  if (map->op == OP_NULL)
  {
    mutt_keymap_free(&map);
  }
  else
  {
    if (last) /* if queue has at least one entry */
    {
      if (STAILQ_NEXT(last, entries))
        STAILQ_INSERT_AFTER(&Keymaps[mtype], last, map, entries);
      else /* last entry in the queue */
        STAILQ_INSERT_TAIL(&Keymaps[mtype], map, entries);
      last->eq = lastpos;
    }
    else /* queue is empty, so insert from head */
    {
      STAILQ_INSERT_HEAD(&Keymaps[mtype], map, entries);
    }
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_unbind_all()

static void km_unbind_all ( struct KeymapList * km_list, unsigned long mode )

static

Free all the keys in the supplied Keymap.

Parameters

km_list	Keymap mapping
mode	Undo bind or macro, e.g. MUTT_UNBIND, MUTT_UNMACRO

Iterate through Keymap and free keys defined either by "macro" or "bind".

Definition at line 163 of file commands.c.

{
  struct Keymap *np = NULL, *tmp = NULL;
 
  STAILQ_FOREACH_SAFE(np, km_list, entries, tmp)
  {
    if (((mode & MUTT_UNBIND) && !np->macro) || ((mode & MUTT_UNMACRO) && np->macro))
    {
      STAILQ_REMOVE(km_list, np, Keymap, entries);
      mutt_keymap_free(&np);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_keymap()

static char * parse_keymap ( enum MenuType * mtypes, struct Buffer * s, int max_menus, int * num_menus, struct Buffer * err, bool bind )

static

Parse a user-config key binding.

Parameters

mtypes	Array for results
s	Buffer containing config string
max_menus	Total number of menus
num_menus	Number of menus this config applies to
err	Buffer for error messages
bind	If true 'bind', otherwise 'macro'

Return values

ptr	Key string for the binding

Expects to see: <menu-string>,<menu-string>,... <key-string>

Note

Caller needs to free the returned string

Definition at line 191 of file commands.c.

{
  struct Buffer *buf = buf_pool_get();
  int i = 0;
  char *q = NULL;
  char *result = NULL;
 
  /* menu name */
  parse_extract_token(buf, s, TOKEN_NO_FLAGS);
  char *p = buf->data;
  if (MoreArgs(s))
  {
    while (i < max_menus)
    {
      q = strchr(p, ',');
      if (q)
        *q = '\0';
 
      int val = mutt_map_get_value(p, MenuNames);
      if (val == -1)
      {
        buf_printf(err, _("%s: no such menu"), p);
        goto done;
      }
      mtypes[i] = val;
      i++;
      if (q)
        p = q + 1;
      else
        break;
    }
    *num_menus = i;
    /* key sequence */
    parse_extract_token(buf, s, TOKEN_NO_FLAGS);
 
    if (buf_at(buf, 0) == '\0')
    {
      buf_printf(err, _("%s: null key sequence"), bind ? "bind" : "macro");
    }
    else if (MoreArgs(s))
    {
      result = buf_strdup(buf);
      goto done;
    }
  }
  else
  {
    buf_printf(err, _("%s: too few arguments"), bind ? "bind" : "macro");
  }
done:
  buf_pool_release(&buf);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_menu()

static void * parse_menu ( bool * menus, char * s, struct Buffer * err )

static

Parse menu-names into an array.

Parameters

menus	Array for results
s	String containing menu-names
err	Buffer for error messages

Return values

NULL

Always

Expects to see: <menu-string>[,<menu-string>]

Definition at line 255 of file commands.c.

{
  char *menu_names_dup = mutt_str_dup(s);
  char *marker = menu_names_dup;
  char *menu_name = NULL;
 
  while ((menu_name = mutt_str_sep(&marker, ",")))
  {
    int value = mutt_map_get_value(menu_name, MenuNames);
    if (value == -1)
    {
      buf_printf(err, _("%s: no such menu"), menu_name);
      break;
    }
    else
    {
      menus[value] = true;
    }
  }
 
  FREE(&menu_names_dup);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_bind()

static enum CommandResult try_bind ( char * key, enum MenuType mtype, char * func, const struct MenuFuncOp * funcs, struct Buffer * err )

static

Try to make a key binding.

Parameters

key	Key name
mtype	Menu type, e.g. MENU_PAGER
func	Function name
funcs	Functions table
err	Buffer for error message

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 288 of file commands.c.

{
  for (int i = 0; funcs[i].name; i++)
  {
    if (mutt_str_equal(func, funcs[i].name))
    {
      return km_bind(key, mtype, funcs[i].op, NULL, NULL, err);
    }
  }
  if (err)
  {
    buf_printf(err, _("Function '%s' not available for menu '%s'"), func,
               mutt_map_get_name(mtype, MenuNames));
  }
  return MUTT_CMD_ERROR; /* Couldn't find an existing function with this name */
}

Here is the call graph for this function:

Here is the caller graph for this function: