* please see the file GPL in the top level source directory.
*/
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include <lib-lib/lib-lib.h>
+
+#include <lib-ui/lib-ui.h>
+#include <lib-ui/menu.h>
#include "mutt.h"
-#include "buffer.h"
-#include "ascii.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 "crypt.h"
-#include "functions.h"
+#define MUTT_FUNCTIONS_VALUES
+#include "functions.def"
struct mapping_t Menus[] = {
{"alias", MENU_ALIAS},
{"postpone", MENU_POST},
{"pgp", MENU_PGP},
{"smime", MENU_SMIME},
-
-#ifdef HAVE_GPGME
{"key_select_pgp", MENU_KEY_SELECT_PGP},
{"key_select_smime", MENU_KEY_SELECT_SMIME},
-#endif
-
-
-#ifdef MIXMASTER
- {"mix", MENU_MIX},
-#endif
-
-
{"query", MENU_QUERY},
{"generic", MENU_GENERIC},
{NULL, 0}
};
-#define mutt_check_menu(s) mutt_getvaluebyname(s, Menus)
-
static struct mapping_t KeyNames[] = {
{"<PageUp>", KEY_PPAGE},
{"<PageDown>", KEY_NPAGE},
#ifdef KEY_ENTER
{"<Enter>", KEY_ENTER},
#endif
- {"<Return>", M_ENTER_C},
+ {"<Return>", '\n'},
{"<Esc>", '\033'},
{"<Tab>", '\t'},
{"<Space>", ' '},
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 = mem_calloc (1, sizeof (struct keymap_t));
- p->len = len;
- p->keys = mem_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)
+static int parse_fkey (const char *s)
{
- char *t;
int n = 0;
- if (s[0] != '<' || ascii_tolower (s[1]) != 'f')
+ if (s[0] != '<' || ascii_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;
- else
- return n;
+ n = strtol(s + 2, (char **)&s, 10);
+ return *s == '>' ? n : -1;
}
/*
*/
static int parse_keycode (const char *s)
{
- if (isdigit ((unsigned char) s[1]) &&
- isdigit ((unsigned char) s[2]) &&
- isdigit ((unsigned char) s[3]) && s[4] == '>') {
- return (s[3] - '0') + (s[2] - '0') * 8 + (s[1] - '0') * 64;
- }
- return -1;
+ int n;
+
+ if (*s != '<')
+ return -1;
+ n = strtol(s + 1, (char **)&s, 8);
+ return *s == '>' ? n : -1;
}
static int parsekeys (const char *str, keycode_t * d, int max)
{
int n, len = max;
- char buff[SHORT_STRING];
+ char buff[STRING];
char c;
char *s, *t;
- strfcpy (buff, str, sizeof (buff));
+ m_strcpy(buff, sizeof(buff), str);
s = buff;
while (*s && len) {
len--;
}
- return (max - len);
+ return max - len;
}
/* insert a key sequence into the specified map. the map is sorted by ASCII
map = allocKeys (len, buf);
map->op = op;
- map->macro = str_dup (macro);
- map->descr = str_dup (descr);
+ map->macro = m_strdup(macro);
+ map->descr = m_strdup(descr);
tmp = Keymaps[menu];
do {
len = tmp->eq;
next = tmp->next;
- mem_free (&tmp->macro);
- mem_free (&tmp->keys);
- mem_free (&tmp->descr);
- mem_free (&tmp);
+ p_delete(&tmp->macro);
+ p_delete(&tmp->keys);
+ p_delete(&tmp->descr);
+ p_delete(&tmp);
tmp = next;
}
while (tmp && len >= pos);
km_bind (s, menu, op, NULL, NULL);
}
-static int get_op (struct binding_t *bindings, const char *start, size_t len)
+static int get_op (struct binding_t *bindings, const char *start, ssize_t len)
{
int i;
for (i = 0; bindings[i].name; i++) {
if (!ascii_strncasecmp (start, bindings[i].name, len) &&
- str_len (bindings[i].name) == len)
+ m_strlen(bindings[i].name) == len)
return bindings[i].op;
}
return NULL;
}
-static void push_string (char *s)
+static void push_string(const char *s)
{
- char *pp, *p = s + str_len (s) - 1;
- size_t l;
+ const char *pp, *p = s + m_strlen(s) - 1;
+ ssize_t l;
int i, op = OP_NULL;
while (p >= s) {
mutt_ungetch (lastkey, 0);
for (; keyslen; keyslen--)
mutt_ungetch (keys[keyslen - 1], 0);
- return (km_dokey (MENU_GENERIC));
+ return km_dokey (MENU_GENERIC);
}
if (menu != MENU_EDITOR) {
/* probably a good idea to flush input here so we can abort macros */
if (!map)
- return (retry_generic (menu, NULL, 0, 0));
+ 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);
+ wtimeout (main_w, (Timeout > 0 ? Timeout : 60) * 1000);
tmp = mutt_getch ();
if (menu != MENU_EDITOR)
- timeout (-1); /* restore blocking operation */
+ wtimeout (main_w, -1); /* restore blocking operation */
LastKey = tmp.ch;
if (LastKey == -1)
/* 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;
}
/* Nope. Business as usual */
while (LastKey > map->keys[pos]) {
if (pos > map->eq || !map->next)
- return (retry_generic (menu, map->keys, pos, LastKey));
+ return retry_generic (menu, map->keys, pos, LastKey);
map = map->next;
}
if (LastKey != map->keys[pos])
- return (retry_generic (menu, map->keys, pos, LastKey));
+ return retry_generic (menu, map->keys, pos, LastKey);
if (++pos == map->len) {
km_bindkey (map[i].seq, menu, map[i].op);
}
-char *km_keyname (int c)
+const char *km_keyname(int c)
{
static char buf[10];
const char *p;
}
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))
+ else if (isprint((unsigned char)c))
snprintf (buf, sizeof (buf), "%c", (unsigned char) c);
else
snprintf (buf, sizeof (buf), "\\x%hx", (unsigned short) c);
- return (buf);
+ return buf;
}
int km_expand_key (char *s, size_t len, struct keymap_t *map)
int p = 0;
if (!map)
- return (0);
+ return 0;
- FOREVER {
- strfcpy (s, km_keyname (map->keys[p]), len);
- len -= (l = str_len (s));
+ for (;;) {
+ m_strcpy(s, len, km_keyname(map->keys[p]));
+ len -= (l = m_strlen(s));
if (++p >= map->len || !len)
- return (1);
+ return 1;
s += l;
}
for (; map; map = map->next)
if (map->op == func)
break;
- return (map);
+ return map;
}
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);
create_bindings (OpPost, MENU_POST);
create_bindings (OpQuery, MENU_QUERY);
create_bindings (OpAlias, MENU_ALIAS);
-
-
- if ((WithCrypto & APPLICATION_PGP))
- create_bindings (OpPgp, MENU_PGP);
-
- if ((WithCrypto & APPLICATION_SMIME))
- create_bindings (OpSmime, MENU_SMIME);
-
-#ifdef CRYPT_BACKEND_GPGME
+ create_bindings (OpPgp, MENU_PGP);
+ create_bindings (OpSmime, MENU_SMIME);
create_bindings (OpPgp, MENU_KEY_SELECT_PGP);
create_bindings (OpSmime, MENU_KEY_SELECT_SMIME);
-#endif
-
-#ifdef MIXMASTER
- create_bindings (OpMix, MENU_MIX);
-
- km_bindkey ("<space>", MENU_MIX, OP_GENERIC_SELECT_ENTRY);
- km_bindkey ("h", MENU_MIX, OP_MIX_CHAIN_PREV);
- km_bindkey ("l", MENU_MIX, OP_MIX_CHAIN_NEXT);
-#endif
/* bindings for the line editor */
create_bindings (OpEditor, MENU_EDITOR);
void km_error_key (int menu)
{
- char buf[SHORT_STRING];
+ char buf[STRING];
struct keymap_t *key;
if (!(key = km_find_func (menu, OP_HELP)))
return;
}
-int mutt_parse_push (BUFFER * buf, BUFFER * s, unsigned long data,
+int mutt_parse_push (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
int r = 0;
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
push_string (buf->data);
- return (r);
+ return r;
}
/* expects to see: <menu-string>,<menu-string>,... <key-string> */
int i = 0;
char *p, *q;
- memset (&buf, 0, sizeof (buf));
+ p_clear(&buf, 1);
/* menu name */
mutt_extract_token (&buf, s, 0);
if (q)
*q = '\0';
- if ((menu[i] = mutt_check_menu (p)) == -1) {
+ if ((menu[i] = mutt_getvaluebyname(p, Menus)) == -1) {
snprintf (err->data, err->dsize, _("%s: no such menu"), p);
goto error;
}
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);
+ return buf.data;
}
else {
- strfcpy (err->data, _("too few arguments"), err->dsize);
+ m_strcpy(err->data, err->dsize, _("too few arguments"));
}
error:
- mem_free (&buf.data);
- return (NULL);
+ p_delete(&buf.data);
+ return NULL;
}
static int
int i;
for (i = 0; bindings[i].name; i++)
- if (str_cmp (func, bindings[i].name) == 0) {
+ if (m_strcmp(func, bindings[i].name) == 0) {
km_bindkey (key, menu, bindings[i].op);
- return (0);
+ return 0;
}
- return (-1);
+ return -1;
}
struct binding_t *km_get_table (int menu)
return OpEditor;
case MENU_QUERY:
return OpQuery;
-
case MENU_PGP:
- return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
-
-#ifdef CRYPT_BACKEND_GPGME
+ return OpPgp;
case MENU_KEY_SELECT_PGP:
return OpPgp;
case MENU_KEY_SELECT_SMIME:
return OpSmime;
-#endif
-
-#ifdef MIXMASTER
- case MENU_MIX:
- return OpMix;
-#endif
-
}
return NULL;
}
/* bind menu-name '<key_sequence>' function-name */
-int mutt_parse_bind (BUFFER * buf, BUFFER * s, unsigned long data,
+int mutt_parse_bind (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
struct binding_t *bindings = NULL;
char *key;
- int menu[sizeof (Menus) / sizeof (struct mapping_t) - 1], r =
+ int menu[countof(Menus) - 1], r =
0, nummenus, i;
- if ((key = parse_keymap (menu, s, sizeof (menu) / sizeof (menu[0]),
- &nummenus, err)) == NULL)
- return (-1);
+ if (!(key = parse_keymap(menu, s, countof(menu), &nummenus, err)))
+ return -1;
/* 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) {
}
}
}
- mem_free (&key);
- return (r);
+ p_delete(&key);
+ return r;
}
/* macro <menu> <key> <macro> <description> */
-int mutt_parse_macro (BUFFER * buf, BUFFER * s, unsigned long data,
+int mutt_parse_macro (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
int menu[sizeof (Menus) / sizeof (struct mapping_t) - 1], r =
if ((key =
parse_keymap (menu, s, sizeof (menu) / sizeof (menu[0]), &nummenus,
err)) == NULL)
- return (-1);
+ return -1;
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 = str_dup (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) {
}
}
- mem_free (&seq);
+ p_delete(&seq);
}
else {
for (i = 0; i < nummenus; ++i) {
}
}
}
- mem_free (&key);
- return (r);
+ p_delete(&key);
+ return r;
}
/* exec function-name */
-int mutt_parse_exec (BUFFER * buf, BUFFER * s, unsigned long data,
+int mutt_parse_exec (BUFFER * buf, BUFFER * s, unsigned long data __attribute__ ((unused)),
BUFFER * err)
{
int ops[128];
char *function;
if (!MoreArgs (s)) {
- strfcpy (err->data, _("exec: no arguments"), err->dsize);
- return (-1);
+ m_strcpy(err->data, err->dsize, _("exec: no arguments"));
+ return -1;
}
do {
&& CurrentMenu != MENU_PAGER)
bindings = OpGeneric;
- ops[nops] = get_op (bindings, function, str_len (function));
+ ops[nops] = get_op (bindings, function, m_strlen(function));
if (ops[nops] == OP_NULL && CurrentMenu != MENU_PAGER)
- ops[nops] = get_op (OpGeneric, function, str_len (function));
+ ops[nops] = get_op (OpGeneric, function, m_strlen(function));
if (ops[nops] == OP_NULL) {
mutt_flushinp ();
mutt_error (_("%s: no such function"), function);
- return (-1);
+ return -1;
}
nops++;
}
- while (MoreArgs (s) && nops < sizeof (ops) / sizeof (ops[0]));
+ while (MoreArgs (s) && nops < ssizeof (ops) / ssizeof (ops[0]));
while (nops)
mutt_ungetch (0, ops[--nops]);
return 0;
}
-
-/*
- * prompts the user to enter a keystroke, and displays the octal value back
- * to the user.
- */
-void mutt_what_key (void)
-{
- int ch;
-
- mvprintw (LINES - 1, 0, _("Enter keys (^G to abort): "));
- do {
- ch = getch ();
- if (ch != ERR && ch != ctrl ('G')) {
- mutt_message (_("Char = %s, Octal = %o, Decimal = %d"),
- km_keyname (ch), ch, ch);
- }
- }
- while (ch != ERR && ch != ctrl ('G'));
-
- mutt_flushinp ();
-}
projects / apps / madmutt.git / blobdiff