# include "config.h"
#endif
+#include <lib-lib/mem.h>
+#include <lib-lib/ascii.h>
+#include <lib-lib/str.h>
+#include <lib-lib/macros.h>
+#include <lib-lib/buffer.h>
+#include <lib-lib/mapping.h>
+
#include "mutt.h"
#include "mutt_menu.h"
#include "mutt_curses.h"
#include "keymap.h"
-#include "mapping.h"
#include "mutt_crypt.h"
-#include "lib/mem.h"
-#include "lib/intl.h"
-#include "lib/str.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
-#include "functions.h"
+#define MUTT_FUNCTIONS_VALUES
+#include "functions.def"
struct mapping_t Menus[] = {
{"alias", MENU_ALIAS},
{"<Space>", ' '},
#ifdef KEY_BTAB
{"<BackTab>", KEY_BTAB},
+#endif
+#ifdef KEY_NEXT
+ {"<Next>", KEY_NEXT},
#endif
{NULL, 0}
};
struct keymap_t *Keymaps[MENU_MAX];
-static struct keymap_t *allocKeys (int len, keycode_t * keys)
+static struct keymap_t *allocKeys(int len, keycode_t *keys)
{
- struct keymap_t *p;
+ struct keymap_t *p;
- p = safe_calloc (1, sizeof (struct keymap_t));
- p->len = len;
- p->keys = safe_malloc (len * sizeof (keycode_t));
- memcpy (p->keys, keys, len * sizeof (keycode_t));
- return (p);
+ p = p_new(struct keymap_t, 1);
+ p->len = len;
+ p->keys = p_dup(keys, len);
+ return p;
}
static int parse_fkey (char *s)
return -1;
}
-static int parsekeys (char *str, keycode_t * d, int max)
+static int parsekeys (const char *str, keycode_t * d, int max)
{
int n, len = max;
char buff[SHORT_STRING];
char c;
char *s, *t;
- strfcpy (buff, str, sizeof (buff));
+ m_strcpy(buff, sizeof(buff), str);
s = buff;
while (*s && len) {
/* insert a key sequence into the specified map. the map is sorted by ASCII
* value (lowest to highest)
*/
-void km_bind (char *s, int menu, int op, char *macro, char *descr)
+void km_bind (const char *s, int menu, int op, char *macro, char *descr)
{
struct keymap_t *map, *tmp, *last = NULL, *next;
keycode_t buf[MAX_SEQ];
map = allocKeys (len, buf);
map->op = op;
- map->macro = safe_strdup (macro);
- map->descr = safe_strdup (descr);
+ map->macro = m_strdup(macro);
+ map->descr = m_strdup(descr);
tmp = Keymaps[menu];
do {
len = tmp->eq;
next = tmp->next;
- FREE (&tmp->macro);
- FREE (&tmp->keys);
- FREE (&tmp->descr);
- FREE (&tmp);
+ p_delete(&tmp->macro);
+ p_delete(&tmp->keys);
+ p_delete(&tmp->descr);
+ p_delete(&tmp);
tmp = next;
}
while (tmp && len >= pos);
Keymaps[menu] = map;
}
-void km_bindkey (char *s, int menu, int op)
+void km_bindkey (const char *s, int menu, int op)
{
km_bind (s, menu, op, NULL, NULL);
}
for (i = 0; bindings[i].name; i++) {
if (!ascii_strncasecmp (start, bindings[i].name, len) &&
- safe_strlen (bindings[i].name) == len)
+ m_strlen(bindings[i].name) == len)
return bindings[i].op;
}
return OP_NULL;
}
-static char *get_func (struct binding_t *bindings, int op)
+static const char *get_func (struct binding_t *bindings, int op)
{
int i;
return NULL;
}
-static void push_string (char *s)
+static void push_string(const char *s)
{
- char *pp, *p = s + safe_strlen (s) - 1;
+ const char *pp, *p = s + m_strlen(s) - 1;
size_t l;
int i, op = OP_NULL;
}
}
}
- mutt_ungetch (*p--, 0);
+ mutt_ungetch ((unsigned char) *p--, 0);
}
}
if (!map)
return (retry_generic (menu, NULL, 0, 0));
- FOREVER {
+ for (;;) {
/* ncurses doesn't return on resized screen when timeout is set to zero */
if (menu != MENU_EDITOR)
timeout ((Timeout > 0 ? Timeout : 60) * 1000);
/* do we have an op already? */
if (tmp.op) {
- char *func = NULL;
+ const char *func = NULL;
struct binding_t *bindings;
/* is this a valid op for this menu? */
/* careful not to feed the <..> as one token. otherwise
* push_string() will push the bogus op right back! */
mutt_ungetch ('>', 0);
- push_string (func);
+ push_string(func);
mutt_ungetch ('<', 0);
break;
}
km_bindkey (map[i].seq, menu, map[i].op);
}
-char *km_keyname (int c)
+const char *km_keyname(int c)
{
static char buf[10];
- char *p;
+ const char *p;
if ((p = mutt_getnamebyvalue (c, KeyNames)))
return p;
if (!map)
return (0);
- FOREVER {
- strfcpy (s, km_keyname (map->keys[p]), len);
- len -= (l = safe_strlen (s));
+ for (;;) {
+ m_strcpy(s, len, km_keyname(map->keys[p]));
+ len -= (l = m_strlen(s));
if (++p >= map->len || !len)
return (1);
void km_init (void)
{
- memset (Keymaps, 0, sizeof (struct keymap_t *) * MENU_MAX);
+ p_clear(Keymaps, MENU_MAX);
create_bindings (OpAttach, MENU_ATTACH);
create_bindings (OpBrowser, MENU_FOLDER);
mutt_extract_token (buf, s, M_TOKEN_CONDENSE);
if (MoreArgs (s)) {
- strfcpy (err->data, _("push: too many arguments"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("push: too many arguments"));
r = -1;
}
else
int i = 0;
char *p, *q;
- memset (&buf, 0, sizeof (buf));
+ p_clear(&buf, 1);
/* menu name */
mutt_extract_token (&buf, s, 0);
mutt_extract_token (&buf, s, 0);
if (!*buf.data) {
- strfcpy (err->data, _("null key sequence"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("null key sequence"));
}
else if (MoreArgs (s))
return (buf.data);
}
else {
- strfcpy (err->data, _("too few arguments"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("too few arguments"));
}
error:
- FREE (&buf.data);
+ p_delete(&buf.data);
return (NULL);
}
int i;
for (i = 0; bindings[i].name; i++)
- if (safe_strcmp (func, bindings[i].name) == 0) {
+ if (m_strcmp(func, bindings[i].name) == 0) {
km_bindkey (key, menu, bindings[i].op);
return (0);
}
/* function to execute */
mutt_extract_token (buf, s, 0);
if (MoreArgs (s)) {
- strfcpy (err->data, _("bind: too many arguments"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("bind: too many arguments"));
r = -1;
}
else if (ascii_strcasecmp ("noop", buf->data) == 0) {
}
}
}
- FREE (&key);
+ p_delete(&key);
return (r);
}
mutt_extract_token (buf, s, M_TOKEN_CONDENSE);
/* make sure the macro sequence is not an empty string */
if (!*buf->data) {
- strfcpy (err->data, _("macro: empty key sequence"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("macro: empty key sequence"));
}
else {
if (MoreArgs (s)) {
- seq = safe_strdup (buf->data);
+ seq = m_strdup(buf->data);
mutt_extract_token (buf, s, M_TOKEN_CONDENSE);
if (MoreArgs (s)) {
- strfcpy (err->data, _("macro: too many arguments"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("macro: too many arguments"));
}
else {
for (i = 0; i < nummenus; ++i) {
}
}
- FREE (&seq);
+ p_delete(&seq);
}
else {
for (i = 0; i < nummenus; ++i) {
}
}
}
- FREE (&key);
+ p_delete(&key);
return (r);
}
char *function;
if (!MoreArgs (s)) {
- strfcpy (err->data, _("exec: no arguments"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("exec: no arguments"));
return (-1);
}
&& CurrentMenu != MENU_PAGER)
bindings = OpGeneric;
- ops[nops] = get_op (bindings, function, safe_strlen (function));
+ ops[nops] = get_op (bindings, function, m_strlen(function));
if (ops[nops] == OP_NULL && CurrentMenu != MENU_PAGER)
- ops[nops] = get_op (OpGeneric, function, safe_strlen (function));
+ ops[nops] = get_op (OpGeneric, function, m_strlen(function));
if (ops[nops] == OP_NULL) {
mutt_flushinp ();