keymap.c File Reference

Manage keymappings. More...

#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "keymap.h"
#include "color/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "functions.h"
#include "init.h"
#include "mutt_globals.h"
#include "mutt_logging.h"
#include "opcodes.h"
#include "options.h"
#include "imap/lib.h"
#include "monitor.h"

Include dependency graph for keymap.c:

Go to the source code of this file.

Data Structures
struct	Extkey
	Map key names from NeoMutt's style to Curses style. More...

Functions
static void	mutt_keymap_free (struct Keymap **km)
	Free a Keymap. More...
static void	mutt_keymaplist_free (struct KeymapList *km_list)
	Free a List of Keymaps. More...
static struct Keymap *	alloc_keys (size_t len, keycode_t *keys)
	Allocate space for a sequence of keys. More...
static int	parse_fkey (char *s)
	Parse a function key string. More...
static int	parse_keycode (const char *s)
	Parse a numeric keycode. More...
static size_t	parsekeys (const char *str, keycode_t *d, size_t max)
	Parse a key string into key codes. More...
static struct Keymap *	km_compare_keys (struct Keymap *k1, struct Keymap *k2, size_t *pos)
	Compare two keymaps' keyscodes and return the bigger one. More...
static enum CommandResult	km_bind_err (const char *s, enum MenuType mtype, int op, char *macro, char *desc, struct Buffer *err)
	Set up a key binding. More...
enum CommandResult	km_bind (char *s, enum MenuType mtype, int op, char *macro, char *desc)
	Bind a key to a macro. More...
static enum CommandResult	km_bindkey_err (const char *s, enum MenuType mtype, int op, struct Buffer *err)
	Bind a key in a Menu to an operation (with error message) More...
static enum CommandResult	km_bindkey (const char *s, enum MenuType mtype, int op)
	Bind a key in a Menu to an operation. More...
static int	get_op (const struct MenuFuncOp *funcs, const char *start, size_t len)
	Get the function by its name. More...
const char *	mutt_get_func (const struct MenuFuncOp *funcs, int op)
	Get the name of a function. More...
static void	generic_tokenize_push_string (char *s, void(*generic_push)(int, int))
	Parse and queue a 'push' command. More...
static struct KeyEvent	retry_generic (enum MenuType mtype, keycode_t *keys, int keyslen, int lastkey)
	Try to find the key in the generic menu bindings. More...
struct KeyEvent	km_dokey_event (enum MenuType mtype)
	Determine what a keypress should do. More...
int	km_dokey (enum MenuType mtype)
	Determine what a keypress should do. More...
static void	create_bindings (const struct MenuOpSeq *map, enum MenuType mtype)
	Attach a set of keybindings to a Menu. More...
static const char *	km_keyname (int c)
	Get the human name for a key. More...
void	mutt_init_abort_key (void)
	Parse the abort_key config string. More...
int	main_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -. More...
static int	km_expand_key_string (char *str, char *buf, size_t buflen)
	Get a human-readable key string. More...
int	km_expand_key (char *s, size_t len, struct Keymap *map)
	Get the key string bound to a Keymap. More...
struct Keymap *	km_find_func (enum MenuType mtype, int func)
	Find a function's mapping in a Menu. More...
static const char *	find_ext_name (const char *key)
	Find the curses name for a key. More...
void	init_extended_keys (void)
	Initialise map of ncurses extended keys. More...
void	km_init (void)
	Initialise all the menu keybindings. More...
void	km_error_key (enum MenuType mtype)
	Handle an unbound key sequence. More...
enum CommandResult	mutt_parse_push (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'push' command - Implements Command::parse() -. More...
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. More...
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. More...
const struct MenuFuncOp *	km_get_table (enum MenuType mtype)
	Lookup a Menu's functions. More...
enum CommandResult	mutt_parse_bind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'bind' command - Implements Command::parse() -. More...
static void *	parse_menu (bool *menus, char *s, struct Buffer *err)
	Parse menu-names into an array. More...
static void	km_unbind_all (struct KeymapList *km_list, unsigned long mode)
	Free all the keys in the supplied Keymap. More...
enum CommandResult	mutt_parse_unbind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unbind' command - Implements Command::parse() -. More...
enum CommandResult	mutt_parse_macro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'macro' command - Implements Command::parse() -. More...
enum CommandResult	mutt_parse_exec (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'exec' command - Implements Command::parse() -. More...
void	mutt_what_key (void)
	Ask the user to press a key. More...
void	mutt_keys_free (void)
	Free the key maps. More...

Variables
static struct Mapping	KeyNames []
	Key name lookup table. More...
keycode_t	AbortKey
	code of key to abort prompts, normally Ctrl-G More...
struct KeymapList	Keymaps [MENU_MAX]
	Array of Keymap keybindings, one for each Menu. More...
static const struct Extkey	ExtKeys []

Detailed Description

Manage keymappings.

Authors

• Michael R. Elkins

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

Function Documentation

mutt_keymap_free()

static void mutt_keymap_free ( struct Keymap **  km )

static

Free a Keymap.

Parameters

km	Keymap to free

Definition at line 177 of file keymap.c.

{
  if (!km || !*km)
    return;
 
  FREE(&(*km)->macro);
  FREE(&(*km)->desc);
  FREE(&(*km)->keys);
  FREE(km);
}

Here is the caller graph for this function:

mutt_keymaplist_free()

static void mutt_keymaplist_free ( struct KeymapList *  km_list )

static

Free a List of Keymaps.

Parameters

km_list

List of Keymaps to free

Definition at line 192 of file keymap.c.

{
  struct Keymap *np = NULL, *tmp = NULL;
  STAILQ_FOREACH_SAFE(np, km_list, entries, tmp)
  {
    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:

alloc_keys()

static struct Keymap * alloc_keys ( size_t  len, keycode_t *  keys  )

static

Allocate space for a sequence of keys.

Parameters

len	Number of keys
keys	Array of keys

Return values

ptr	Sequence of keys

Definition at line 208 of file keymap.c.

{
  struct Keymap *p = mutt_mem_calloc(1, sizeof(struct Keymap));
  p->len = len;
  p->keys = mutt_mem_calloc(len, sizeof(keycode_t));
  memcpy(p->keys, keys, len * sizeof(keycode_t));
  return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_fkey()

static int parse_fkey ( char *  s )

static

Parse a function key string.

Parameters

s	String to parse

Return values

num	Number of the key

Given "<f8>", it will return 8.

Definition at line 224 of file keymap.c.

{
  char *t = NULL;
  int n = 0;
 
  if ((s[0] != '<') || (tolower(s[1]) != 'f'))
    return -1;
 
  for (t = s + 2; *t && isdigit((unsigned char) *t); t++)
  {
    n *= 10;
    n += *t - '0';
  }
 
  if (*t != '>')
    return -1;
  return n;
}

Here is the caller graph for this function:

parse_keycode()

static int parse_keycode ( const char *  s )

static

Parse a numeric keycode.

Parameters

s	String to parse

Return values

num	Number of the key

This function parses the string <NNN> and uses the octal value as the key to bind.

Definition at line 251 of file keymap.c.

{
  char *end_char = NULL;
  long int result = strtol(s + 1, &end_char, 8);
  /* allow trailing whitespace, eg.  < 1001 > */
  while (IS_SPACE(*end_char))
    end_char++;
  /* negative keycodes don't make sense, also detect overflow */
  if ((*end_char != '>') || (result < 0) || (result == LONG_MAX))
  {
    return -1;
  }
 
  return result;
}

Here is the caller graph for this function:

parsekeys()

static size_t parsekeys ( const char *  str, keycode_t *  d, size_t  max  )

static

Parse a key string into key codes.

Parameters

str	Key string
d	Array for key codes
max	Maximum length of key sequence

Return values

num	Length of key sequence

Definition at line 274 of file keymap.c.

{
  int n;
  size_t len = max;
  char buf[128] = { 0 };
  char c;
  char *t = NULL;
 
  mutt_str_copy(buf, str, sizeof(buf));
  char *s = buf;
 
  while (*s && len)
  {
    *d = '\0';
    if ((*s == '<') && (t = strchr(s, '>')))
    {
      t++;
      c = *t;
      *t = '\0';
 
      n = mutt_map_get_value(s, KeyNames);
      if (n != -1)
      {
        s = t;
        *d = n;
      }
      else if ((n = parse_fkey(s)) > 0)
      {
        s = t;
        *d = KEY_F(n);
      }
      else if ((n = parse_keycode(s)) > 0)
      {
        s = t;
        *d = n;
      }
 
      *t = c;
    }
 
    if (!*d)
    {
      *d = (unsigned char) *s;
      s++;
    }
    d++;
    len--;
  }
 
  return max - len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_compare_keys()

static struct Keymap * km_compare_keys ( struct Keymap *  k1, struct Keymap *  k2, size_t *  pos  )

static

Compare two keymaps' keyscodes and return the bigger one.

Parameters

k1	first keymap to compare
k2	second keymap to compare
pos	position where the two keycodes differ

Return values

ptr	Keymap with a bigger ASCII keycode

Definition at line 333 of file keymap.c.

{
  while (*pos < k1->len && *pos < k2->len)
  {
    if (k1->keys[*pos] < k2->keys[*pos])
      return k2;
    else if (k1->keys[*pos] > k2->keys[*pos])
      return k1;
    else
      *pos = *pos + 1;
  }
 
  return NULL;
}

Here is the caller graph for this function:

km_bind_err()

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

static

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 361 of file keymap.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))
      {
        /* Overwrite with the different lengths, warn */
        /* TODO: MAX_SEQ here is wrong */
        char old_binding[MAX_SEQ] = { 0 };
        char new_binding[MAX_SEQ] = { 0 };
        km_expand_key(old_binding, MAX_SEQ, map);
        km_expand_key(new_binding, MAX_SEQ, np);
        char *err_msg = _("Binding '%s' will alias '%s'  Before, try: 'bind %s %s noop'  https://neomutt.org/guide/configuration.html#bind-warnings");
        if (err)
        {
          /* err was passed, put the string there */
          mutt_buffer_printf(err, err_msg, old_binding, new_binding,
                             mutt_map_get_name(mtype, MenuNames), new_binding);
        }
        else
        {
          mutt_error(err_msg, old_binding, new_binding,
                     mutt_map_get_name(mtype, MenuNames), new_binding);
        }
        rc = MUTT_CMD_WARNING;
      }
 
      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_bind()

enum CommandResult km_bind	(	char *	s,
		enum MenuType	mtype,
		int	op,
		char *	macro,
		char *	desc
	)

Bind a key to a macro.

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)

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 458 of file keymap.c.

{
  return km_bind_err(s, mtype, op, macro, desc, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_bindkey_err()

static enum CommandResult km_bindkey_err ( const char *  s, enum MenuType  mtype, int  op, struct Buffer *  err  )

static

Bind a key in a Menu to an operation (with error message)

Parameters

s	Key string
mtype	Menu type, e.g. MENU_PAGER
op	Operation, e.g. OP_DELETE
err	Buffer for error message

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 471 of file keymap.c.

{
  return km_bind_err(s, mtype, op, NULL, NULL, err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_bindkey()

static enum CommandResult km_bindkey ( const char *  s, enum MenuType  mtype, int  op  )

static

Bind a key in a Menu to an operation.

Parameters

s	Key string
mtype	Menu type, e.g. MENU_PAGER
op	Operation, e.g. OP_DELETE

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 484 of file keymap.c.

{
  return km_bindkey_err(s, mtype, op, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_op()

static int get_op ( const struct MenuFuncOp *  funcs, const char *  start, size_t  len  )

static

Get the function by its name.

Parameters

funcs	Functions table
start	Name of function to find
len	Length of string to match

Return values

num	Operation, e.g. OP_DELETE

Definition at line 496 of file keymap.c.

{
  for (int i = 0; funcs[i].name; i++)
  {
    if (mutt_istrn_equal(start, funcs[i].name, len) && (mutt_str_len(funcs[i].name) == len))
    {
      return funcs[i].op;
    }
  }
 
  return OP_NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_func()

const char * mutt_get_func	(	const struct MenuFuncOp *	funcs,
		int	op
	)

Get the name of a function.

Parameters

funcs	Functions table
op	Operation, e.g. OP_DELETE

Return values

ptr	Name of function
NULL	Operation not found

Note

This returns a static string.

Definition at line 518 of file keymap.c.

{
  for (int i = 0; funcs[i].name; i++)
  {
    if (funcs[i].op == op)
      return funcs[i].name;
  }
 
  return NULL;
}

Here is the caller graph for this function:

generic_tokenize_push_string()

static void generic_tokenize_push_string ( char *  s, void(*)(int, int)  generic_push  )

static

Parse and queue a 'push' command.

Parameters

s	String to push into the key queue
generic_push	Callback function to add events to macro queue

Parses s for <function> syntax and adds the whole sequence to either the macro or unget buffer. This function is invoked by the next two defines below.

Definition at line 538 of file keymap.c.

{
  char *pp = NULL;
  char *p = s + mutt_str_len(s) - 1;
  size_t l;
  int i, op = OP_NULL;
 
  while (p >= s)
  {
    /* if we see something like "<PageUp>", look to see if it is a real
     * function name and return the corresponding value */
    if (*p == '>')
    {
      for (pp = p - 1; pp >= s && *pp != '<'; pp--)
        ; // do nothing
 
      if (pp >= s)
      {
        i = parse_fkey(pp);
        if (i > 0)
        {
          generic_push(KEY_F(i), 0);
          p = pp - 1;
          continue;
        }
 
        l = p - pp + 1;
        for (i = 0; KeyNames[i].name; i++)
        {
          if (mutt_istrn_equal(pp, KeyNames[i].name, l))
            break;
        }
        if (KeyNames[i].name)
        {
          /* found a match */
          generic_push(KeyNames[i].value, 0);
          p = pp - 1;
          continue;
        }
 
        /* See if it is a valid command
         * skip the '<' and the '>' when comparing */
        for (enum MenuType j = 0; MenuNames[j].name; j++)
        {
          const struct MenuFuncOp *funcs = km_get_table(MenuNames[j].value);
          if (funcs)
          {
            op = get_op(funcs, pp + 1, l - 2);
            if (op != OP_NULL)
              break;
          }
        }
 
        if (op != OP_NULL)
        {
          generic_push(0, op);
          p = pp - 1;
          continue;
        }
      }
    }
    generic_push((unsigned char) *p--, 0); /* independent 8 bits chars */
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

retry_generic()

static struct KeyEvent retry_generic ( enum MenuType  mtype, keycode_t *  keys, int  keyslen, int  lastkey  )

static

Try to find the key in the generic menu bindings.

Parameters

mtype	Menu type, e.g. MENU_PAGER
keys	Array of keys to return to the input queue
keyslen	Number of keys in the array
lastkey	Last key pressed (to return to input queue)

Return values

num	Operation, e.g. OP_DELETE

Definition at line 611 of file keymap.c.

{
  if (lastkey)
    mutt_unget_ch(lastkey);
  for (; keyslen; keyslen--)
    mutt_unget_ch(keys[keyslen - 1]);
 
  if ((mtype != MENU_EDITOR) && (mtype != MENU_GENERIC) && (mtype != MENU_PAGER))
  {
    return km_dokey_event(MENU_GENERIC);
  }
  if ((mtype != MENU_EDITOR) && (mtype != MENU_GENERIC))
  {
    /* probably a good idea to flush input here so we can abort macros */
    mutt_flushinp();
  }
 
  return (struct KeyEvent){ .ch = mutt_getch().ch, .op = OP_NULL };
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_dokey_event()

struct KeyEvent km_dokey_event

(

enum MenuType

mtype

)

Determine what a keypress should do.

Parameters

mtype

Menu type, e.g. MENU_EDITOR

Return values

ptr

Event

Definition at line 637 of file keymap.c.

{
  struct KeyEvent tmp = { OP_NULL, OP_NULL };
  struct Keymap *map = STAILQ_FIRST(&Keymaps[mtype]);
  int pos = 0;
  int n = 0;
 
  if (!map && (mtype != MENU_EDITOR))
    return retry_generic(mtype, NULL, 0, 0);
 
#ifdef USE_IMAP
  const short c_imap_keepalive = cs_subset_number(NeoMutt->sub, "imap_keepalive");
#endif
 
  while (true)
  {
    const short c_timeout = cs_subset_number(NeoMutt->sub, "timeout");
    int i = (c_timeout > 0) ? c_timeout : 60;
#ifdef USE_IMAP
    /* keepalive may need to run more frequently than `$timeout` allows */
    if (c_imap_keepalive)
    {
      if (c_imap_keepalive >= i)
        imap_keepalive();
      else
      {
        while (c_imap_keepalive && (c_imap_keepalive < i))
        {
          tmp = mutt_getch_timeout(c_imap_keepalive * 1000);
          /* If a timeout was not received, or the window was resized, exit the
           * loop now.  Otherwise, continue to loop until reaching a total of
           * $timeout seconds.  */
          if ((tmp.op != OP_TIMEOUT) || SigWinch)
            goto gotkey;
#ifdef USE_INOTIFY
          if (MonitorFilesChanged)
            goto gotkey;
#endif
          i -= c_imap_keepalive;
          imap_keepalive();
        }
      }
    }
#endif
 
    tmp = mutt_getch_timeout(i * 1000);
 
#ifdef USE_IMAP
  gotkey:
#endif
    /* hide timeouts, but not window resizes, from the line editor. */
    if ((mtype == MENU_EDITOR) && (tmp.op == OP_TIMEOUT) && !SigWinch)
      continue;
 
    if ((tmp.op == OP_TIMEOUT) || (tmp.op == OP_ABORT))
    {
      return tmp;
    }
 
    /* do we have an op already? */
    if (tmp.op != OP_NULL)
    {
      const char *func = NULL;
      const struct MenuFuncOp *funcs = NULL;
 
      /* is this a valid op for this menu type? */
      if ((funcs = km_get_table(mtype)) && (func = mutt_get_func(funcs, tmp.op)))
        return tmp;
 
      if ((mtype != MENU_EDITOR) && (mtype != MENU_PAGER) && (mtype != MENU_GENERIC))
      {
        /* check generic menu type */
        funcs = OpGeneric;
        func = mutt_get_func(funcs, tmp.op);
        if (func)
          return tmp;
      }
 
      /* Sigh. Valid function but not in this context.
       * Find the literal string and push it back */
      for (i = 0; MenuNames[i].name; i++)
      {
        funcs = km_get_table(MenuNames[i].value);
        if (funcs)
        {
          func = mutt_get_func(funcs, tmp.op);
          if (func)
          {
            mutt_unget_ch('>');
            mutt_unget_string(func);
            mutt_unget_ch('<');
            break;
          }
        }
      }
      /* continue to chew */
      if (func)
        continue;
    }
 
    if (!map)
      return tmp;
 
    /* Nope. Business as usual */
    while (tmp.ch > map->keys[pos])
    {
      if ((pos > map->eq) || !STAILQ_NEXT(map, entries))
        return retry_generic(mtype, map->keys, pos, tmp.ch);
      map = STAILQ_NEXT(map, entries);
    }
 
    if (tmp.ch != map->keys[pos])
      return retry_generic(mtype, map->keys, pos, tmp.ch);
 
    if (++pos == map->len)
    {
      if (map->op != OP_MACRO)
        return (struct KeyEvent){ .ch = tmp.ch, .op = map->op };
 
      /* OptIgnoreMacroEvents turns off processing the MacroEvents buffer
       * in mutt_getch().  Generating new macro events during that time would
       * result in undesired behavior once the option is turned off.
       *
       * Originally this returned -1, however that results in an unbuffered
       * username or password prompt being aborted.  Returning OP_NULL allows
       * mutt_enter_string_full() to display the keybinding pressed instead.
       *
       * It may be unexpected for a macro's keybinding to be returned,
       * but less so than aborting the prompt.  */
      if (OptIgnoreMacroEvents)
      {
        return (struct KeyEvent){ .ch = tmp.ch, .op = OP_NULL };
      }
 
      if (n++ == 10)
      {
        mutt_flushinp();
        mutt_error(_("Macro loop detected"));
        return (struct KeyEvent){ .ch = '\0', .op = -1 };
      }
 
      generic_tokenize_push_string(map->macro, mutt_push_macro_event);
      map = STAILQ_FIRST(&Keymaps[mtype]);
      pos = 0;
    }
  }
 
  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_dokey()

int km_dokey

(

enum MenuType

mtype

)

Determine what a keypress should do.

Parameters

mtype

Menu type, e.g. MENU_EDITOR

Return values

>0	Function to execute
OP_NULL	No function bound to key sequence
-1	Error occurred while reading input
-2	A timeout or sigwinch occurred

Definition at line 795 of file keymap.c.

{
  return km_dokey_event(mtype).op;
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_bindings()

static void create_bindings ( const struct MenuOpSeq *  map, enum MenuType  mtype  )

static

Attach a set of keybindings to a Menu.

Parameters

map	Key bindings
mtype	Menu type, e.g. MENU_PAGER

Definition at line 805 of file keymap.c.

{
  STAILQ_INIT(&Keymaps[mtype]);
 
  for (int i = 0; map[i].op != 0; i++)
    if (map[i].seq)
      km_bindkey(map[i].seq, mtype, map[i].op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_keyname()

static const char * km_keyname ( int  c )

static

Get the human name for a key.

Parameters

c

Key code

Return values

ptr	Name of the key

Note

This returns a pointer to a static buffer.

Definition at line 821 of file keymap.c.

{
  static char buf[35];
 
  const char *p = mutt_map_get_name(c, KeyNames);
  if (p)
    return p;
 
  if ((c < 256) && (c > -128) && iscntrl((unsigned char) c))
  {
    if (c < 0)
      c += 256;
 
    if (c < 128)
    {
      buf[0] = '^';
      buf[1] = (c + '@') & 0x7f;
      buf[2] = '\0';
    }
    else
      snprintf(buf, sizeof(buf), "\\%d%d%d", c >> 6, (c >> 3) & 7, c & 7);
  }
  else if ((c >= KEY_F0) && (c < KEY_F(256))) /* this maximum is just a guess */
    sprintf(buf, "<F%d>", c - KEY_F0);
  else if (IsPrint(c))
    snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
  else
    snprintf(buf, sizeof(buf), "\\x%hx", (unsigned short) c);
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_init_abort_key()

void mutt_init_abort_key

(

void

)

Parse the abort_key config string.

Parse the string into $abort_key and put the keycode into AbortKey.

Definition at line 857 of file keymap.c.

{
  keycode_t buf[2];
  const char *const c_abort_key = cs_subset_string(NeoMutt->sub, "abort_key");
  size_t len = parsekeys(c_abort_key, buf, mutt_array_size(buf));
  if (len == 0)
  {
    mutt_error(_("Abort key is not set, defaulting to Ctrl-G"));
    AbortKey = ctrl('G');
    return;
  }
  if (len > 1)
  {
    mutt_warning(_("Specified abort key sequence (%s) will be truncated to first key"),
                 c_abort_key);
  }
  AbortKey = buf[0];
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_expand_key_string()

static int km_expand_key_string ( char *  str, char *  buf, size_t  buflen  )

static

Get a human-readable key string.

Parameters

str	Raw key string
buf	Buffer for the key string
buflen	Length of buffer

Return values

num	Length of string

Definition at line 903 of file keymap.c.

{
  size_t len = 0;
  for (; *str; str++)
  {
    const char *key = km_keyname(*str);
    size_t keylen = mutt_str_len(key);
 
    mutt_str_copy(buf, key, buflen);
    buf += keylen;
    buflen -= keylen;
    len += keylen;
  }
 
  return len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_expand_key()

int km_expand_key	(	char *	s,
		size_t	len,
		struct Keymap *	map
	)

Get the key string bound to a Keymap.

Parameters

s	Buffer for the key string
len	Length of buffer
map	Keybinding map

Return values

1	Success
0	Error

Definition at line 928 of file keymap.c.

{
  if (!map)
    return 0;
 
  int p = 0;
 
  while (true)
  {
    mutt_str_copy(s, km_keyname(map->keys[p]), len);
    const size_t l = mutt_str_len(s);
    len -= l;
 
    if ((++p >= map->len) || !len)
      return 1;
 
    s += l;
  }
 
  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_find_func()

struct Keymap * km_find_func	(	enum MenuType	mtype,
		int	func
	)

Find a function's mapping in a Menu.

Parameters

mtype	Menu type, e.g. MENU_PAGER
func	Function, e.g. OP_DELETE

Return values

ptr	Keymap for the function

Definition at line 956 of file keymap.c.

{
  struct Keymap *np = NULL;
  STAILQ_FOREACH(np, &Keymaps[mtype], entries)
  {
    if (np->op == func)
      break;
  }
  return np;
}

Here is the caller graph for this function:

find_ext_name()

static const char * find_ext_name ( const char *  key )

static

Find the curses name for a key.

Parameters

key

Key name

Return values

ptr	Curses name

Look up NeoMutt's name for a key and find the ncurses extended name for it.

Note

This returns a static string.

Definition at line 976 of file keymap.c.

{
  for (int j = 0; ExtKeys[j].name; j++)
  {
    if (strcasecmp(key, ExtKeys[j].name) == 0)
      return ExtKeys[j].sym;
  }
  return 0;
}

Here is the caller graph for this function:

init_extended_keys()

void init_extended_keys

(

void

)

Initialise map of ncurses extended keys.

Determine the keycodes for ncurses extended keys and fill in the KeyNames array.

This function must be called after initscr(), or tigetstr() returns -1. This creates a bit of a chicken-and-egg problem because km_init() is called prior to start_curses(). This means that the default keybindings can't include any of the extended keys because they won't be defined until later.

Definition at line 996 of file keymap.c.

{
#ifdef HAVE_USE_EXTENDED_NAMES
  use_extended_names(true);
 
  for (int j = 0; KeyNames[j].name; j++)
  {
    if (KeyNames[j].value == -1)
    {
      const char *keyname = find_ext_name(KeyNames[j].name);
 
      if (keyname)
      {
        char *s = tigetstr((char *) keyname);
        if (s && ((long) (s) != -1))
        {
          int code = key_defined(s);
          if (code > 0)
            KeyNames[j].value = code;
        }
      }
    }
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_init()

void km_init

(

void

)

Initialise all the menu keybindings.

Definition at line 1025 of file keymap.c.

{
  memset(Keymaps, 0, sizeof(struct KeymapList) * MENU_MAX);
 
  create_bindings(AliasDefaultBindings, MENU_ALIAS);
  create_bindings(AttachDefaultBindings, MENU_ATTACH);
#ifdef USE_AUTOCRYPT
  create_bindings(AutocryptAcctDefaultBindings, MENU_AUTOCRYPT_ACCT);
#endif
  create_bindings(BrowserDefaultBindings, MENU_FOLDER);
  create_bindings(ComposeDefaultBindings, MENU_COMPOSE);
  create_bindings(EditorDefaultBindings, MENU_EDITOR);
  create_bindings(GenericDefaultBindings, MENU_GENERIC);
  create_bindings(IndexDefaultBindings, MENU_INDEX);
#ifdef MIXMASTER
  create_bindings(MixDefaultBindings, MENU_MIX);
#endif
  create_bindings(PagerDefaultBindings, MENU_PAGER);
  create_bindings(PostDefaultBindings, MENU_POSTPONE);
  create_bindings(QueryDefaultBindings, MENU_QUERY);
 
  if (WithCrypto & APPLICATION_PGP)
    create_bindings(PgpDefaultBindings, MENU_PGP);
  if (WithCrypto & APPLICATION_SMIME)
    create_bindings(SmimeDefaultBindings, MENU_SMIME);
 
#ifdef CRYPT_BACKEND_GPGME
  create_bindings(PgpDefaultBindings, MENU_KEY_SELECT_PGP);
  create_bindings(SmimeDefaultBindings, MENU_KEY_SELECT_SMIME);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_error_key()

void km_error_key

(

enum MenuType

mtype

)

Handle an unbound key sequence.

Parameters

mtype

Menu type, e.g. MENU_PAGER

Definition at line 1061 of file keymap.c.

{
  char buf[128] = { 0 };
  int p, op;
 
  struct Keymap *key = km_find_func(mtype, OP_HELP);
  if (!key && (mtype != MENU_EDITOR) && (mtype != MENU_PAGER))
    key = km_find_func(MENU_GENERIC, OP_HELP);
  if (!key)
  {
    mutt_error(_("Key is not bound"));
    return;
  }
 
  /* Make sure the key is really the help key in this menu.
   *
   * OP_END_COND is used as a barrier to ensure nothing extra
   * is left in the unget buffer.
   *
   * Note that km_expand_key() + tokenize_unget_string() should
   * not be used here: control sequences are expanded to a form
   * (e.g. "^H") not recognized by km_dokey(). */
  mutt_unget_op(OP_END_COND);
  p = key->len;
  while (p--)
    mutt_unget_ch(key->keys[p]);
 
  /* Note, e.g. for the index menu:
   *   bind generic ?   noop
   *   bind generic ,a  help
   *   bind index   ,ab quit
   * The index keybinding shadows the generic binding.
   * OP_END_COND will be read and returned as the op.
   *
   *   bind generic ?   noop
   *   bind generic dq  help
   *   bind index   d   delete-message
   * OP_DELETE will be returned as the op, leaving "q" + OP_END_COND
   * in the unget buffer.
   */
  op = km_dokey(mtype);
  if (op != OP_END_COND)
    mutt_flush_unget_to_endcond();
  if (op != OP_HELP)
  {
    mutt_error(_("Key is not bound"));
    return;
  }
 
  km_expand_key(buf, sizeof(buf), key);
  mutt_error(_("Key is not bound.  Press '%s' for help."), buf);
}

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 1145 of file keymap.c.

{
  struct Buffer buf;
  int i = 0;
  char *q = NULL;
 
  mutt_buffer_init(&buf);
 
  /* menu name */
  mutt_extract_token(&buf, s, MUTT_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)
      {
        mutt_buffer_printf(err, _("%s: no such menu"), p);
        goto error;
      }
      mtypes[i] = val;
      i++;
      if (q)
        p = q + 1;
      else
        break;
    }
    *num_menus = i;
    /* key sequence */
    mutt_extract_token(&buf, s, MUTT_TOKEN_NO_FLAGS);
 
    if (buf.data[0] == '\0')
    {
      mutt_buffer_printf(err, _("%s: null key sequence"), bind ? "bind" : "macro");
    }
    else if (MoreArgs(s))
      return buf.data;
  }
  else
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), bind ? "bind" : "macro");
  }
error:
  FREE(&buf.data);
  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 1207 of file keymap.c.

{
  for (int i = 0; funcs[i].name; i++)
  {
    if (mutt_str_equal(func, funcs[i].name))
    {
      return km_bindkey_err(key, mtype, funcs[i].op, err);
    }
  }
  if (err)
  {
    mutt_buffer_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:

km_get_table()

const struct MenuFuncOp * km_get_table

(

enum MenuType

mtype

)

Lookup a Menu's functions.

Parameters

mtype

Menu type, e.g. MENU_EDITOR

Return values

ptr	Array of functions

Definition at line 1230 of file keymap.c.

{
  switch (mtype)
  {
    case MENU_ALIAS:
      return OpAlias;
    case MENU_ATTACH:
      return OpAttach;
#ifdef USE_AUTOCRYPT
    case MENU_AUTOCRYPT_ACCT:
      return OpAutocrypt;
#endif
    case MENU_COMPOSE:
      return OpCompose;
    case MENU_EDITOR:
      return OpEditor;
    case MENU_FOLDER:
      return OpBrowser;
    case MENU_GENERIC:
      return OpGeneric;
    case MENU_INDEX:
      return OpIndex;
#ifdef CRYPT_BACKEND_GPGME
    case MENU_KEY_SELECT_PGP:
      return OpPgp;
    case MENU_KEY_SELECT_SMIME:
      return OpSmime;
#endif
#ifdef MIXMASTER
    case MENU_MIX:
      return OpMix;
#endif
    case MENU_PAGER:
      return OpPager;
    case MENU_PGP:
      return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
    case MENU_POSTPONE:
      return OpPostpone;
    case MENU_QUERY:
      return OpQuery;
    default:
      return NULL;
  }
}

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 1377 of file keymap.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)
    {
      mutt_buffer_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:

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 1406 of file keymap.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:

mutt_what_key()

void mutt_what_key

(

void

)

Ask the user to press a key.

Displays the octal value back to the user.

Definition at line 1638 of file keymap.c.

{
  int ch;
 
  struct MuttWindow *win = msgwin_get_window();
  if (!win)
    return;
 
  mutt_curses_set_normal_backed_color_by_id(MT_COLOR_PROMPT);
  mutt_window_mvprintw(win, 0, 0, _("Enter keys (%s to abort): "), km_keyname(AbortKey));
  mutt_curses_set_color_by_id(MT_COLOR_NORMAL);
  enum MuttCursorState cursor = mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
  do
  {
    ch = getch();
    if ((ch != ERR) && (ch != AbortKey))
    {
      mutt_message(_("Char = %s, Octal = %o, Decimal = %d"), km_keyname(ch), ch, ch);
      mutt_window_move(win, 0, 0);
    }
  } while (ch != ERR && ch != AbortKey);
  mutt_curses_set_cursor(cursor);
 
  mutt_flushinp();
  mutt_clear_error();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_keys_free()

void mutt_keys_free

(

void

)

Free the key maps.

Definition at line 1668 of file keymap.c.

{
  for (int i = 0; i < MENU_MAX; i++)
  {
    mutt_keymaplist_free(&Keymaps[i]);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

KeyNames

struct Mapping KeyNames[]

static

Key name lookup table.

Definition at line 62 of file keymap.c.

AbortKey

keycode_t AbortKey

code of key to abort prompts, normally Ctrl-G

key to abort edits etc, normally Ctrl-G

Definition at line 124 of file keymap.c.

Keymaps

struct KeymapList Keymaps[MENU_MAX]

Array of Keymap keybindings, one for each Menu.

Definition at line 126 of file keymap.c.

ExtKeys

const struct Extkey ExtKeys[]

static

Definition at line 137 of file keymap.c.