lib.c File Reference

Key helper functions. More...

#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mutt/lib.h"
#include "gui/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"

Include dependency graph for lib.c:

Go to the source code of this file.

Functions
void	mutt_keymap_free (struct Keymap **ptr)
	Free a Keymap.
struct Keymap *	alloc_keys (size_t len, keycode_t *keys)
	Allocate space for a sequence of keys.
static int	parse_fkey (char *s)
	Parse a function key string.
static int	parse_keycode (const char *s)
	Parse a numeric keycode.
size_t	parsekeys (const char *str, keycode_t *d, size_t max)
	Parse a key string into key codes.
struct Keymap *	km_compare_keys (struct Keymap *k1, struct Keymap *k2, size_t *pos)
	Compare two keymaps' keyscodes and return the bigger one.
int	get_op (const struct MenuFuncOp *funcs, const char *start, size_t len)
	Get the function by its name.
const char *	mutt_get_func (const struct MenuFuncOp *funcs, int op)
	Get the name of a function.
void	generic_tokenize_push_string (char *s)
	Parse and queue a 'push' command.
const char *	km_keyname (int c)
	Get the human name for a key.
int	km_expand_key (char *s, size_t len, struct Keymap *map)
	Get the key string bound to a Keymap.
int	km_expand_key_string (char *str, char *buf, size_t buflen)
	Get a human-readable key string.
struct Keymap *	km_find_func (enum MenuType mtype, int func)
	Find a function's mapping in a Menu.
const struct MenuFuncOp *	km_get_table (enum MenuType mtype)
	Lookup a Menu's functions.

Variables
const struct MenuFuncOp	OpAlias []
	Functions for the Alias Menu.
const struct MenuFuncOp	OpAttachment []
	Functions for the Attachment Menu.
const struct MenuFuncOp	OpAutocrypt []
	Functions for the Autocrypt Account.
const struct MenuFuncOp	OpBrowser []
	Functions for the file Browser Menu.
const struct MenuFuncOp	OpCompose []
	Functions for the Compose Menu.
const struct MenuFuncOp	OpEditor []
	Functions for the Editor Menu.
const struct MenuFuncOp	OpIndex []
	Functions for the Index Menu.
const struct MenuFuncOp	OpPager []
	Functions for the Pager Menu.
const struct MenuFuncOp	OpPgp []
	Functions for the Pgp Menu.
const struct MenuFuncOp	OpPostponed []
	Functions for the Postpone Menu.
const struct MenuFuncOp	OpQuery []
	Functions for the external Query Menu.
const struct MenuFuncOp	OpSmime []
	Functions for the Smime Menu.
struct Mapping	KeyNames []
	Key name lookup table.
keycode_t	AbortKey
	code of key to abort prompts, normally Ctrl-G
struct KeymapList	Keymaps [MENU_MAX]
	Array of key mappings, one for each MenuType.

Detailed Description

Key helper functions.

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

Function Documentation

mutt_keymap_free()

void mutt_keymap_free

(

struct Keymap **

ptr

)

Free a Keymap.

Parameters

ptr	Keymap to free

Definition at line 131 of file lib.c.

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

Here is the caller graph for this function:

alloc_keys()

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

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 150 of file lib.c.

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

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 166 of file lib.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 193 of file lib.c.

{
  char *end_char = NULL;
  long int result = strtol(s + 1, &end_char, 8);
  /* allow trailing whitespace, eg.  < 1001 > */
  while (isspace(*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()

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

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 216 of file lib.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()

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

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 275 of file lib.c.

{
  *pos = 0;
 
  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:

get_op()

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

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 299 of file lib.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 321 of file lib.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()

void generic_tokenize_push_string

(

char *

s

)

Parse and queue a 'push' command.

Parameters

s	String to push into the key queue

Parses s for <function> syntax and adds the whole sequence the macro buffer.

Definition at line 338 of file lib.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)
        {
          mutt_push_macro_event(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 */
          mutt_push_macro_event(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)
        {
          mutt_push_macro_event(0, op);
          p = pp - 1;
          continue;
        }
      }
    }
    mutt_push_macro_event((unsigned char) *p--, 0); /* independent 8 bits chars */
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_keyname()

const char * km_keyname

(

int

c

)

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 410 of file lib.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 */
  {
    snprintf(buf, sizeof(buf), "<F%d>", c - KEY_F0);
  }
  else if ((c < 256) && (c >= -128) && IsPrint(c))
  {
    snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
  }
  else
  {
    snprintf(buf, sizeof(buf), "<%ho>", (unsigned short) c);
  }
  return buf;
}

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 457 of file lib.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_expand_key_string()

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

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 486 of file lib.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_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 509 of file lib.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:

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 525 of file lib.c.

{
  switch (mtype)
  {
    case MENU_ALIAS:
      return OpAlias;
    case MENU_ATTACHMENT:
      return OpAttachment;
#ifdef USE_AUTOCRYPT
    case MENU_AUTOCRYPT:
      return OpAutocrypt;
#endif
    case MENU_COMPOSE:
      return OpCompose;
    case MENU_DIALOG:
      return OpDialog;
    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
    case MENU_PAGER:
      return OpPager;
    case MENU_PGP:
      return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
    case MENU_POSTPONED:
      return OpPostponed;
    case MENU_QUERY:
      return OpQuery;
    default:
      return NULL;
  }
}

Here is the caller graph for this function:

Variable Documentation

OpAlias

const struct MenuFuncOp OpAlias[]

extern

Functions for the Alias Menu.

Definition at line 60 of file functions.c.

OpAttachment

const struct MenuFuncOp OpAttachment[]

extern

Functions for the Attachment Menu.

Definition at line 62 of file functions.c.

OpAutocrypt

const struct MenuFuncOp OpAutocrypt[]

extern

Functions for the Autocrypt Account.

Definition at line 54 of file functions.c.

OpBrowser

const struct MenuFuncOp OpBrowser[]

extern

Functions for the file Browser Menu.

Definition at line 72 of file functions.c.

OpCompose

const struct MenuFuncOp OpCompose[]

extern

Functions for the Compose Menu.

Definition at line 87 of file functions.c.

OpEditor

const struct MenuFuncOp OpEditor[]

extern

Functions for the Editor Menu.

Definition at line 53 of file functions.c.

OpIndex

const struct MenuFuncOp OpIndex[]

extern

Functions for the Index Menu.

Definition at line 90 of file functions.c.

OpPager

const struct MenuFuncOp OpPager[]

extern

Functions for the Pager Menu.

Definition at line 71 of file functions.c.

OpPgp

const struct MenuFuncOp OpPgp[]

extern

Functions for the Pgp Menu.

Definition at line 42 of file functions.c.

OpPostponed

const struct MenuFuncOp OpPostponed[]

extern

Functions for the Postpone Menu.

Definition at line 52 of file functions.c.

OpQuery

const struct MenuFuncOp OpQuery[]

extern

Functions for the external Query Menu.

Definition at line 76 of file functions.c.

OpSmime

const struct MenuFuncOp OpSmime[]

extern

Functions for the Smime Menu.

Definition at line 52 of file functions.c.

KeyNames

struct Mapping KeyNames[]

Key name lookup table.

Definition at line 60 of file lib.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 122 of file lib.c.

Keymaps

struct KeymapList Keymaps[MENU_MAX]

Array of key mappings, one for each MenuType.

Array of Keymap keybindings, one for each Menu.

Definition at line 125 of file lib.c.