NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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 Keymapalloc_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 Keymapkm_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 Keymapkm_find_func (enum MenuType mtype, int func)
 Find a function's mapping in a Menu.
 
const struct MenuFuncOpkm_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 OpMixmaster []
 Functions for the Mixmaster 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

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
ptrKeymap to free

Definition at line 134 of file lib.c.

135{
136 if (!ptr || !*ptr)
137 return;
138
139 struct Keymap *km = *ptr;
140 FREE(&km->macro);
141 FREE(&km->desc);
142 FREE(&km->keys);
143
144 FREE(ptr);
145}
#define FREE(x)
Definition: memory.h:45
A keyboard mapping.
Definition: lib.h:65
keycode_t * keys
key sequence
Definition: lib.h:71
char * macro
Macro expansion (op == OP_MACRO)
Definition: lib.h:66
char * desc
Description of a macro for the help menu.
Definition: lib.h:67
+ 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
lenNumber of keys
keysArray of keys
Return values
ptrSequence of keys

Definition at line 153 of file lib.c.

154{
155 struct Keymap *p = mutt_mem_calloc(1, sizeof(struct Keymap));
156 p->len = len;
157 p->keys = mutt_mem_calloc(len, sizeof(keycode_t));
158 memcpy(p->keys, keys, len * sizeof(keycode_t));
159 return p;
160}
short keycode_t
Type for key storage, the rest of neomutt works fine with int type.
Definition: lib.h:55
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:51
short len
Length of key sequence (unit: sizeof (keycode_t))
Definition: lib.h:70
+ 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
sString to parse
Return values
numNumber of the key

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

Definition at line 169 of file lib.c.

170{
171 char *t = NULL;
172 int n = 0;
173
174 if ((s[0] != '<') || (tolower(s[1]) != 'f'))
175 return -1;
176
177 for (t = s + 2; *t && isdigit((unsigned char) *t); t++)
178 {
179 n *= 10;
180 n += *t - '0';
181 }
182
183 if (*t != '>')
184 return -1;
185 return n;
186}
+ Here is the caller graph for this function:

◆ parse_keycode()

static int parse_keycode ( const char *  s)
static

Parse a numeric keycode.

Parameters
sString to parse
Return values
numNumber of the key

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

Definition at line 196 of file lib.c.

197{
198 char *end_char = NULL;
199 long int result = strtol(s + 1, &end_char, 8);
200 /* allow trailing whitespace, eg. < 1001 > */
201 while (isspace(*end_char))
202 end_char++;
203 /* negative keycodes don't make sense, also detect overflow */
204 if ((*end_char != '>') || (result < 0) || (result == LONG_MAX))
205 {
206 return -1;
207 }
208
209 return result;
210}
+ 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
strKey string
dArray for key codes
maxMaximum length of key sequence
Return values
numLength of key sequence

Definition at line 219 of file lib.c.

220{
221 int n;
222 size_t len = max;
223 char buf[128] = { 0 };
224 char c;
225 char *t = NULL;
226
227 mutt_str_copy(buf, str, sizeof(buf));
228 char *s = buf;
229
230 while (*s && len)
231 {
232 *d = '\0';
233 if ((*s == '<') && (t = strchr(s, '>')))
234 {
235 t++;
236 c = *t;
237 *t = '\0';
238
240 if (n != -1)
241 {
242 s = t;
243 *d = n;
244 }
245 else if ((n = parse_fkey(s)) > 0)
246 {
247 s = t;
248 *d = KEY_F(n);
249 }
250 else if ((n = parse_keycode(s)) > 0)
251 {
252 s = t;
253 *d = n;
254 }
255
256 *t = c;
257 }
258
259 if (!*d)
260 {
261 *d = (unsigned char) *s;
262 s++;
263 }
264 d++;
265 len--;
266 }
267
268 return max - len;
269}
static int parse_keycode(const char *s)
Parse a numeric keycode.
Definition: lib.c:196
struct Mapping KeyNames[]
Key name lookup table.
Definition: lib.c:63
static int parse_fkey(char *s)
Parse a function key string.
Definition: lib.c:169
int mutt_map_get_value(const char *name, const struct Mapping *map)
Lookup the constant for a string.
Definition: mapping.c:85
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:581
+ 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
k1first keymap to compare
k2second keymap to compare
posposition where the two keycodes differ
Return values
ptrKeymap with a bigger ASCII keycode

Definition at line 278 of file lib.c.

279{
280 *pos = 0;
281
282 while (*pos < k1->len && *pos < k2->len)
283 {
284 if (k1->keys[*pos] < k2->keys[*pos])
285 return k2;
286 else if (k1->keys[*pos] > k2->keys[*pos])
287 return k1;
288 else
289 *pos = *pos + 1;
290 }
291
292 return NULL;
293}
+ 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
funcsFunctions table
startName of function to find
lenLength of string to match
Return values
numOperation, e.g. OP_DELETE

Definition at line 302 of file lib.c.

303{
304 for (int i = 0; funcs[i].name; i++)
305 {
306 if (mutt_istrn_equal(start, funcs[i].name, len) && (mutt_str_len(funcs[i].name) == len))
307 {
308 return funcs[i].op;
309 }
310 }
311
312 return OP_NULL;
313}
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
bool mutt_istrn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings ignoring case (to a maximum), safely.
Definition: string.c:453
const char * name
Name of the function.
Definition: lib.h:102
int op
Operation, e.g. OP_DELETE.
Definition: lib.h:103
+ 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
funcsFunctions table
opOperation, e.g. OP_DELETE
Return values
ptrName of function
NULLOperation not found
Note
This returns a static string.

Definition at line 324 of file lib.c.

325{
326 for (int i = 0; funcs[i].name; i++)
327 {
328 if (funcs[i].op == op)
329 return funcs[i].name;
330 }
331
332 return NULL;
333}
+ 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
sString to push into the key queue

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

Definition at line 341 of file lib.c.

342{
343 char *pp = NULL;
344 char *p = s + mutt_str_len(s) - 1;
345 size_t l;
346 int i, op = OP_NULL;
347
348 while (p >= s)
349 {
350 /* if we see something like "<PageUp>", look to see if it is a real
351 * function name and return the corresponding value */
352 if (*p == '>')
353 {
354 for (pp = p - 1; pp >= s && *pp != '<'; pp--)
355 ; // do nothing
356
357 if (pp >= s)
358 {
359 i = parse_fkey(pp);
360 if (i > 0)
361 {
362 mutt_push_macro_event(KEY_F(i), 0);
363 p = pp - 1;
364 continue;
365 }
366
367 l = p - pp + 1;
368 for (i = 0; KeyNames[i].name; i++)
369 {
370 if (mutt_istrn_equal(pp, KeyNames[i].name, l))
371 break;
372 }
373 if (KeyNames[i].name)
374 {
375 /* found a match */
376 mutt_push_macro_event(KeyNames[i].value, 0);
377 p = pp - 1;
378 continue;
379 }
380
381 /* See if it is a valid command
382 * skip the '<' and the '>' when comparing */
383 for (enum MenuType j = 0; MenuNames[j].name; j++)
384 {
385 const struct MenuFuncOp *funcs = km_get_table(MenuNames[j].value);
386 if (funcs)
387 {
388 op = get_op(funcs, pp + 1, l - 2);
389 if (op != OP_NULL)
390 break;
391 }
392 }
393
394 if (op != OP_NULL)
395 {
397 p = pp - 1;
398 continue;
399 }
400 }
401 }
402 mutt_push_macro_event((unsigned char) *p--, 0); /* independent 8 bits chars */
403 }
404}
void mutt_push_macro_event(int ch, int op)
Add the character/operation to the macro buffer.
Definition: get.c:155
const struct MenuFuncOp * km_get_table(enum MenuType mtype)
Lookup a Menu's functions.
Definition: lib.c:528
int get_op(const struct MenuFuncOp *funcs, const char *start, size_t len)
Get the function by its name.
Definition: lib.c:302
const char * name
String value.
Definition: mapping.h:34
Mapping between a function and an operation.
Definition: lib.h:101
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:37
MenuType
Types of GUI selections.
Definition: type.h:36
+ 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
cKey code
Return values
ptrName of the key
Note
This returns a pointer to a static buffer.

Definition at line 413 of file lib.c.

414{
415 static char buf[35];
416
417 const char *p = mutt_map_get_name(c, KeyNames);
418 if (p)
419 return p;
420
421 if ((c < 256) && (c > -128) && iscntrl((unsigned char) c))
422 {
423 if (c < 0)
424 c += 256;
425
426 if (c < 128)
427 {
428 buf[0] = '^';
429 buf[1] = (c + '@') & 0x7f;
430 buf[2] = '\0';
431 }
432 else
433 {
434 snprintf(buf, sizeof(buf), "\\%d%d%d", c >> 6, (c >> 3) & 7, c & 7);
435 }
436 }
437 else if ((c >= KEY_F0) && (c < KEY_F(256))) /* this maximum is just a guess */
438 {
439 snprintf(buf, sizeof(buf), "<F%d>", c - KEY_F0);
440 }
441 else if ((c < 256) && (c >= -128) && IsPrint(c))
442 {
443 snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
444 }
445 else
446 {
447 snprintf(buf, sizeof(buf), "<%ho>", (unsigned short) c);
448 }
449 return buf;
450}
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
#define IsPrint(ch)
Definition: mbyte.h:40
+ 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
sBuffer for the key string
lenLength of buffer
mapKeybinding map
Return values
1Success
0Error

Definition at line 460 of file lib.c.

461{
462 if (!map)
463 return 0;
464
465 int p = 0;
466
467 while (true)
468 {
469 mutt_str_copy(s, km_keyname(map->keys[p]), len);
470 const size_t l = mutt_str_len(s);
471 len -= l;
472
473 if ((++p >= map->len) || !len)
474 return 1;
475
476 s += l;
477 }
478
479 /* not reached */
480}
const char * km_keyname(int c)
Get the human name for a key.
Definition: lib.c:413
+ 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
strRaw key string
bufBuffer for the key string
buflenLength of buffer
Return values
numLength of string

Definition at line 489 of file lib.c.

490{
491 size_t len = 0;
492 for (; *str; str++)
493 {
494 const char *key = km_keyname(*str);
495 size_t keylen = mutt_str_len(key);
496
497 mutt_str_copy(buf, key, buflen);
498 buf += keylen;
499 buflen -= keylen;
500 len += keylen;
501 }
502
503 return len;
504}
+ 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
mtypeMenu type, e.g. MENU_PAGER
funcFunction, e.g. OP_DELETE
Return values
ptrKeymap for the function

Definition at line 512 of file lib.c.

513{
514 struct Keymap *np = NULL;
515 STAILQ_FOREACH(np, &Keymaps[mtype], entries)
516 {
517 if (np->op == func)
518 break;
519 }
520 return np;
521}
struct KeymapList Keymaps[MENU_MAX]
Array of key mappings, one for each MenuType.
Definition: lib.c:128
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
short op
Operation to perform.
Definition: lib.h:68
+ 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
mtypeMenu type, e.g. MENU_EDITOR
Return values
ptrArray of functions

Definition at line 528 of file lib.c.

529{
530 switch (mtype)
531 {
532 case MENU_ALIAS:
533 return OpAlias;
534 case MENU_ATTACHMENT:
535 return OpAttachment;
536#ifdef USE_AUTOCRYPT
537 case MENU_AUTOCRYPT:
538 return OpAutocrypt;
539#endif
540 case MENU_COMPOSE:
541 return OpCompose;
542 case MENU_DIALOG:
543 return OpDialog;
544 case MENU_EDITOR:
545 return OpEditor;
546 case MENU_FOLDER:
547 return OpBrowser;
548 case MENU_GENERIC:
549 return OpGeneric;
550 case MENU_INDEX:
551 return OpIndex;
552#ifdef CRYPT_BACKEND_GPGME
554 return OpPgp;
556 return OpSmime;
557#endif
558#ifdef MIXMASTER
559 case MENU_MIXMASTER:
560 return OpMixmaster;
561#endif
562 case MENU_PAGER:
563 return OpPager;
564 case MENU_PGP:
565 return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
566 case MENU_POSTPONED:
567 return OpPostponed;
568 case MENU_QUERY:
569 return OpQuery;
570 default:
571 return NULL;
572 }
573}
const struct MenuFuncOp OpGeneric[]
Functions for the Generic Menu.
Definition: functions.c:68
const struct MenuFuncOp OpDialog[]
Functions for Simple Dialogs.
Definition: functions.c:60
const struct MenuFuncOp OpQuery[]
Functions for the external Query Menu.
Definition: functions.c:73
const struct MenuFuncOp OpPostponed[]
Functions for the Postpone Menu.
Definition: functions.c:52
const struct MenuFuncOp OpIndex[]
Functions for the Index Menu.
Definition: functions.c:94
const struct MenuFuncOp OpCompose[]
Functions for the Compose Menu.
Definition: functions.c:90
const struct MenuFuncOp OpMixmaster[]
Functions for the Mixmaster Menu.
Definition: functions.c:49
const struct MenuFuncOp OpSmime[]
Functions for the Smime Menu.
Definition: functions.c:52
const struct MenuFuncOp OpBrowser[]
Functions for the file Browser Menu.
Definition: functions.c:74
const struct MenuFuncOp OpAutocrypt[]
Functions for the Autocrypt Account.
Definition: functions.c:52
const struct MenuFuncOp OpPager[]
Functions for the Pager Menu.
Definition: functions.c:71
const struct MenuFuncOp OpEditor[]
Functions for the Editor Menu.
Definition: functions.c:53
const struct MenuFuncOp OpAttachment[]
Functions for the Attachment Menu.
Definition: functions.c:64
const struct MenuFuncOp OpPgp[]
Functions for the Pgp Menu.
Definition: functions.c:42
const struct MenuFuncOp OpAlias[]
Functions for the Alias Menu.
Definition: functions.c:59
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define WithCrypto
Definition: lib.h:116
@ MENU_KEY_SELECT_PGP
Select a PGP key.
Definition: type.h:48
@ MENU_INDEX
Index panel (list of emails)
Definition: type.h:51
@ MENU_DIALOG
Simple Dialog.
Definition: type.h:43
@ MENU_MIXMASTER
Create/edit a Mixmaster chain.
Definition: type.h:53
@ MENU_KEY_SELECT_SMIME
Select a SMIME key.
Definition: type.h:49
@ MENU_QUERY
Select from results of external query.
Definition: type.h:58
@ MENU_AUTOCRYPT
Autocrypt Account menu.
Definition: type.h:40
@ MENU_COMPOSE
Compose an email.
Definition: type.h:42
@ MENU_ATTACHMENT
Select an attachment.
Definition: type.h:38
@ MENU_PGP
PGP encryption menu.
Definition: type.h:56
@ MENU_GENERIC
Generic selection list.
Definition: type.h:46
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:55
@ MENU_EDITOR
Text entry area.
Definition: type.h:44
@ MENU_ALIAS
Select an email address by its alias.
Definition: type.h:37
@ MENU_FOLDER
General file/mailbox browser.
Definition: type.h:45
@ MENU_POSTPONED
Select a postponed email.
Definition: type.h:57
+ Here is the caller graph for this function:

Variable Documentation

◆ OpAlias

const struct MenuFuncOp OpAlias[]
extern

Functions for the Alias Menu.

Definition at line 59 of file functions.c.

◆ OpAttachment

const struct MenuFuncOp OpAttachment[]
extern

Functions for the Attachment Menu.

Definition at line 64 of file functions.c.

◆ OpAutocrypt

const struct MenuFuncOp OpAutocrypt[]
extern

Functions for the Autocrypt Account.

Definition at line 52 of file functions.c.

◆ OpBrowser

const struct MenuFuncOp OpBrowser[]
extern

Functions for the file Browser Menu.

Definition at line 74 of file functions.c.

◆ OpCompose

const struct MenuFuncOp OpCompose[]
extern

Functions for the Compose Menu.

Definition at line 90 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 94 of file functions.c.

◆ OpMixmaster

const struct MenuFuncOp OpMixmaster[]
extern

Functions for the Mixmaster Menu.

Definition at line 49 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 73 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 63 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 125 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 128 of file lib.c.