#include <lib-lib/str.h>
#include <lib-lib/macros.h>
#include <lib-lib/buffer.h>
+#include <lib-lib/mapping.h>
+
+#include <lib-ui/curses.h>
+#include <lib-ui/menu.h>
#include "mutt.h"
-#include "mutt_menu.h"
-#include "mutt_curses.h"
#include "keymap.h"
-#include "mapping.h"
-#include "mutt_crypt.h"
+#include <lib-crypt/crypt.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},
return p;
}
-static int parse_fkey (char *s)
+static int parse_fkey (const char *s)
{
- char *t;
+ const char *t;
int n = 0;
if (s[0] != '<' || ascii_tolower (s[1]) != 'f')
char c;
char *s, *t;
- strfcpy (buff, str, sizeof (buff));
+ m_strcpy(buff, sizeof(buff), str);
s = buff;
while (*s && len) {
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;
static void push_string(const char *s)
{
const char *pp, *p = s + m_strlen(s) - 1;
- size_t l;
+ ssize_t l;
int i, op = OP_NULL;
while (p >= s) {
return (0);
for (;;) {
- strfcpy (s, km_keyname (map->keys[p]), len);
+ m_strcpy(s, len, km_keyname(map->keys[p]));
len -= (l = m_strlen(s));
if (++p >= map->len || !len)
create_bindings (OpAlias, MENU_ALIAS);
- if ((WithCrypto & APPLICATION_PGP))
- create_bindings (OpPgp, MENU_PGP);
-
- if ((WithCrypto & APPLICATION_SMIME))
- create_bindings (OpSmime, MENU_SMIME);
+ create_bindings (OpPgp, MENU_PGP);
+ create_bindings (OpSmime, MENU_SMIME);
#ifdef CRYPT_BACKEND_GPGME
create_bindings (OpPgp, MENU_KEY_SELECT_PGP);
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
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:
p_delete(&buf.data);
return OpQuery;
case MENU_PGP:
- return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
+ return OpPgp;
#ifdef CRYPT_BACKEND_GPGME
case MENU_KEY_SELECT_PGP:
}
/* 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;
/* 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) {
}
/* 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 =
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)) {
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) {
}
/* 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);
+ m_strcpy(err->data, err->dsize, _("exec: no arguments"));
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]);