keymap.c

   1 /*
   2  * Copyright (C) 1996-2000,2002 Michael R. Elkins <me@mutt.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "mutt_menu.h"
  25 #include "mutt_curses.h"
  26 #include "keymap.h"
  27 #include "mapping.h"
  28 #include "mutt_crypt.h"
  29 #ifdef USE_IMAP
  30 #include "imap/imap.h"
  31 #endif
  32
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <ctype.h>
  36
  37 #include "functions.h"
  38
  39 struct mapping_t Menus[] = {
  40  { "alias",     MENU_ALIAS },
  41  { "attach",    MENU_ATTACH },
  42  { "browser",   MENU_FOLDER },
  43  { "compose",   MENU_COMPOSE },
  44  { "editor",    MENU_EDITOR },
  45  { "index",     MENU_MAIN },
  46  { "pager",     MENU_PAGER },
  47  { "postpone",  MENU_POST },
  48  { "pgp",       MENU_PGP },
  49  { "smime",     MENU_SMIME },
  50 #ifdef CRYPT_BACKEND_GPGME
  51  { "key_select_pgp",    MENU_KEY_SELECT_PGP },
  52  { "key_select_smime",  MENU_KEY_SELECT_SMIME },
  53 #endif
  54
  55 #ifdef MIXMASTER
  56   { "mix",      MENU_MIX },
  57 #endif
  58
  59
  60  { "query",     MENU_QUERY },
  61  { "generic",   MENU_GENERIC },
  62  { NULL,        0 }
  63 };
  64
  65 #define mutt_check_menu(s) mutt_getvaluebyname(s, Menus)
  66
  67 static struct mapping_t KeyNames[] = {
  68   { "<PageUp>", KEY_PPAGE },
  69   { "<PageDown>",       KEY_NPAGE },
  70   { "<Up>",     KEY_UP },
  71   { "<Down>",   KEY_DOWN },
  72   { "<Right>",  KEY_RIGHT },
  73   { "<Left>",   KEY_LEFT },
  74   { "<Delete>", KEY_DC },
  75   { "<BackSpace>",KEY_BACKSPACE },
  76   { "<Insert>", KEY_IC },
  77   { "<Home>",   KEY_HOME },
  78   { "<End>",    KEY_END },
  79 #ifdef KEY_ENTER
  80   { "<Enter>",  KEY_ENTER },
  81 #endif
  82   { "<Return>", M_ENTER_C },
  83   { "<Esc>",    '\033' },
  84   { "<Tab>",    '\t' },
  85   { "<Space>",  ' ' },
  86 #ifdef KEY_BTAB
  87   { "<BackTab>", KEY_BTAB },
  88 #endif
  89 #ifdef KEY_NEXT
  90   { "<Next>",    KEY_NEXT },
  91 #endif
  92 #ifdef NCURSES_VERSION
  93   /* extensions supported by ncurses.  values are filled in during initialization */
  94
  95   /* CTRL+key */
  96   { "<C-Up>",   -1 },
  97   { "<C-Down>", -1 },
  98   { "<C-Left>", -1 },
  99   { "<C-Right>",        -1 },
 100   { "<C-Home>", -1 },
 101   { "<C-End>",  -1 },
 102   { "<C-Next>", -1 },
 103   { "<C-Prev>", -1 },
 104
 105   /* SHIFT+key */
 106   { "<S-Up>",   -1 },
 107   { "<S-Down>", -1 },
 108   { "<S-Left>", -1 },
 109   { "<S-Right>",        -1 },
 110   { "<S-Home>", -1 },
 111   { "<S-End>",  -1 },
 112   { "<S-Next>", -1 },
 113   { "<S-Prev>", -1 },
 114
 115   /* ALT+key */
 116   { "<A-Up>",   -1 },
 117   { "<A-Down>", -1 },
 118   { "<A-Left>", -1 },
 119   { "<A-Right>",        -1 },
 120   { "<A-Home>", -1 },
 121   { "<A-End>",  -1 },
 122   { "<A-Next>", -1 },
 123   { "<A-Prev>", -1 },
 124 #endif /* NCURSES_VERSION */
 125   { NULL,       0 }
 126 };
 127
 128 /* contains the last key the user pressed */
 129 int LastKey;
 130
 131 struct keymap_t *Keymaps[MENU_MAX];
 132
 133 static struct keymap_t *allocKeys (int len, keycode_t *keys)
 134 {
 135   struct keymap_t *p;
 136
 137   p = safe_calloc (1, sizeof (struct keymap_t));
 138   p->len = len;
 139   p->keys = safe_malloc (len * sizeof (keycode_t));
 140   memcpy (p->keys, keys, len * sizeof (keycode_t));
 141   return (p);
 142 }
 143
 144 static int parse_fkey(char *s)
 145 {
 146   char *t;
 147   int n = 0;
 148
 149   if(s[0] != '<' || ascii_tolower(s[1]) != 'f')
 150     return -1;
 151
 152   for(t = s + 2; *t && isdigit((unsigned char) *t); t++)
 153   {
 154     n *= 10;
 155     n += *t - '0';
 156   }
 157
 158   if(*t != '>')
 159     return -1;
 160   else
 161     return n;
 162 }
 163
 164 /*
 165  * This function parses the string <NNN> and uses the octal value as the key
 166  * to bind.
 167  */
 168 static int parse_keycode (const char *s)
 169 {
 170     const char *endChar;
 171     long int result = strtol(s+1, &endChar, 8);
 172     /* allow trailing whitespace, eg.  < 1001 > */
 173     while (ISSPACE(*endChar))
 174         ++endChar;
 175     /* negative keycodes don't make sense, also detect overflow */
 176     if (*endChar != '>' || result < 0 || result == LONG_MAX) {
 177         return -1;
 178     }
 179     return result;
 180 }
 181
 182 static int parsekeys (const char *str, keycode_t *d, int max)
 183 {
 184   int n, len = max;
 185   char buff[SHORT_STRING];
 186   char c;
 187   char *s, *t;
 188
 189   strfcpy(buff, str, sizeof(buff));
 190   s = buff;
 191
 192   while (*s && len)
 193   {
 194     *d = '\0';
 195     if(*s == '<' && (t = strchr(s, '>')))
 196     {
 197       t++; c = *t; *t = '\0';
 198
 199       if ((n = mutt_getvaluebyname (s, KeyNames)) != -1)
 200       {
 201         s = t;
 202         *d = n;
 203       }
 204       else if ((n = parse_fkey(s)) > 0)
 205       {
 206         s = t;
 207         *d = KEY_F (n);
 208       }
 209       else if ((n = parse_keycode(s)) > 0)
 210       {
 211         s = t;
 212         *d = n;
 213       }
 214
 215       *t = c;
 216     }
 217
 218     if(!*d)
 219     {
 220       *d = (unsigned char)*s;
 221       s++;
 222     }
 223     d++;
 224     len--;
 225   }
 226
 227   return (max - len);
 228 }
 229
 230 /* insert a key sequence into the specified map.  the map is sorted by ASCII
 231  * value (lowest to highest)
 232  */
 233 void km_bind (char *s, int menu, int op, char *macro, char *descr)
 234 {
 235   struct keymap_t *map, *tmp, *last = NULL, *next;
 236   keycode_t buf[MAX_SEQ];
 237   int len, pos = 0, lastpos = 0;
 238
 239   len = parsekeys (s, buf, MAX_SEQ);
 240
 241   map = allocKeys (len, buf);
 242   map->op = op;
 243   map->macro = safe_strdup (macro);
 244   map->descr = safe_strdup (descr);
 245
 246   tmp = Keymaps[menu];
 247
 248   while (tmp)
 249   {
 250     if (pos >= len || pos >= tmp->len)
 251     {
 252       /* map and tmp match, but have different lengths, so overwrite */
 253       do
 254       {
 255         len = tmp->eq;
 256         next = tmp->next;
 257         FREE (&tmp->macro);
 258         FREE (&tmp->keys);
 259         FREE (&tmp->descr);
 260         FREE (&tmp);
 261         tmp = next;
 262       }
 263       while (tmp && len >= pos);
 264       map->eq = len;
 265       break;
 266     }
 267     else if (buf[pos] == tmp->keys[pos])
 268       pos++;
 269     else if (buf[pos] < tmp->keys[pos])
 270     {
 271       /* found location to insert between last and tmp */
 272       map->eq = pos;
 273       break;
 274     }
 275     else /* buf[pos] > tmp->keys[pos] */
 276     {
 277       last = tmp;
 278       lastpos = pos;
 279       if (pos > tmp->eq)
 280         pos = tmp->eq;
 281       tmp = tmp->next;
 282     }
 283   }
 284
 285   map->next = tmp;
 286   if (last)
 287   {
 288     last->next = map;
 289     last->eq = lastpos;
 290   }
 291   else
 292     Keymaps[menu] = map;
 293 }
 294
 295 void km_bindkey (char *s, int menu, int op)
 296 {
 297   km_bind (s, menu, op, NULL, NULL);
 298 }
 299
 300 static int get_op (struct binding_t *bindings, const char *start, size_t len)
 301 {
 302   int i;
 303
 304   for (i = 0; bindings[i].name; i++)
 305   {
 306     if (!ascii_strncasecmp (start, bindings[i].name, len) &&
 307         mutt_strlen (bindings[i].name) == len)
 308       return bindings[i].op;
 309   }
 310
 311   return OP_NULL;
 312 }
 313
 314 static char *get_func (struct binding_t *bindings, int op)
 315 {
 316   int i;
 317
 318   for (i = 0; bindings[i].name; i++)
 319   {
 320     if (bindings[i].op == op)
 321       return bindings[i].name;
 322   }
 323
 324   return NULL;
 325 }
 326
 327 static void push_string (char *s)
 328 {
 329   char *pp, *p = s + mutt_strlen (s) - 1;
 330   size_t l;
 331   int i, op = OP_NULL;
 332
 333   while (p >= s)
 334   {
 335     /* if we see something like "<PageUp>", look to see if it is a real
 336        function name and return the corresponding value */
 337     if (*p == '>')
 338     {
 339       for (pp = p - 1; pp >= s && *pp != '<'; pp--)
 340         ;
 341       if (pp >= s)
 342       {
 343         if ((i = parse_fkey (pp)) > 0)
 344         {
 345           mutt_ungetch (KEY_F (i), 0);
 346           p = pp - 1;
 347           continue;
 348         }
 349
 350         l = p - pp + 1;
 351         for (i = 0; KeyNames[i].name; i++)
 352         {
 353           if (!ascii_strncasecmp (pp, KeyNames[i].name, l))
 354             break;
 355         }
 356         if (KeyNames[i].name)
 357         {
 358           /* found a match */
 359           mutt_ungetch (KeyNames[i].value, 0);
 360           p = pp - 1;
 361           continue;
 362         }
 363
 364         /* See if it is a valid command
 365          * skip the '<' and the '>' when comparing */
 366         for (i = 0; Menus[i].name; i++)
 367         {
 368           struct binding_t *binding = km_get_table (Menus[i].value);
 369           if (binding)
 370           {
 371             op = get_op (binding, pp + 1, l - 2);
 372             if (op != OP_NULL)
 373               break;
 374           }
 375         }
 376
 377         if (op != OP_NULL)
 378         {
 379           mutt_ungetch (0, op);
 380           p = pp - 1;
 381           continue;
 382         }
 383       }
 384     }
 385     mutt_ungetch ((unsigned char)*p--, 0);      /* independent 8 bits chars */
 386   }
 387 }
 388
 389 static int retry_generic (int menu, keycode_t *keys, int keyslen, int lastkey)
 390 {
 391   if (menu != MENU_EDITOR && menu != MENU_GENERIC && menu != MENU_PAGER)
 392   {
 393     if (lastkey)
 394       mutt_ungetch (lastkey, 0);
 395     for (; keyslen; keyslen--)
 396       mutt_ungetch (keys[keyslen - 1], 0);
 397     return (km_dokey (MENU_GENERIC));
 398   }
 399   if (menu != MENU_EDITOR)
 400   {
 401     /* probably a good idea to flush input here so we can abort macros */
 402     mutt_flushinp ();
 403   }
 404   return OP_NULL;
 405 }
 406
 407 /* return values:
 408  *      >0              function to execute
 409  *      OP_NULL         no function bound to key sequence
 410  *      -1              error occured while reading input
 411  */
 412 int km_dokey (int menu)
 413 {
 414   event_t tmp;
 415   struct keymap_t *map = Keymaps[menu];
 416   int pos = 0;
 417   int n = 0;
 418   int i;
 419
 420   if (!map)
 421     return (retry_generic (menu, NULL, 0, 0));
 422
 423   FOREVER
 424   {
 425     i = Timeout > 0 ? Timeout : 60;
 426 #ifdef USE_IMAP
 427     /* keepalive may need to run more frequently than Timeout allows */
 428     if (ImapKeepalive)
 429     {
 430       if (ImapKeepalive >= i)
 431         imap_keepalive ();
 432       else
 433         while (ImapKeepalive && ImapKeepalive < i)
 434         {
 435           timeout (ImapKeepalive * 1000);
 436           tmp = mutt_getch ();
 437           timeout (-1);
 438           if (tmp.ch != -2)
 439             /* something other than timeout */
 440             goto gotkey;
 441           i -= ImapKeepalive;
 442           imap_keepalive ();
 443         }
 444     }
 445 #endif
 446
 447     timeout (i * 1000);
 448     tmp = mutt_getch();
 449     timeout (-1);
 450
 451     /* hide timeouts from line editor */
 452     if (menu == MENU_EDITOR && tmp.ch == -2)
 453       continue;
 454
 455   gotkey:
 456     LastKey = tmp.ch;
 457     if (LastKey < 0)
 458       return -1;
 459
 460     /* do we have an op already? */
 461     if (tmp.op)
 462     {
 463       char *func = NULL;
 464       struct binding_t *bindings;
 465
 466       /* is this a valid op for this menu? */
 467       if ((bindings = km_get_table (menu)) &&
 468           (func = get_func (bindings, tmp.op)))
 469         return tmp.op;
 470
 471       if (menu == MENU_EDITOR && get_func (OpEditor, tmp.op))
 472         return tmp.op;
 473
 474       if (menu != MENU_EDITOR && menu != MENU_PAGER)
 475       {
 476         /* check generic menu */
 477         bindings = OpGeneric;
 478         if ((func = get_func (bindings, tmp.op)))
 479           return tmp.op;
 480       }
 481
 482       /* Sigh. Valid function but not in this context.
 483        * Find the literal string and push it back */
 484       for (i = 0; Menus[i].name; i++)
 485       {
 486         bindings = km_get_table (Menus[i].value);
 487         if (bindings)
 488         {
 489           func = get_func (bindings, tmp.op);
 490           if (func)
 491           {
 492             /* careful not to feed the <..> as one token. otherwise
 493             * push_string() will push the bogus op right back! */
 494             mutt_ungetch ('>', 0);
 495             push_string (func);
 496             mutt_ungetch ('<', 0);
 497             break;
 498           }
 499         }
 500       }
 501       /* continue to chew */
 502       if (func)
 503         continue;
 504     }
 505
 506     /* Nope. Business as usual */
 507     while (LastKey > map->keys[pos])
 508     {
 509       if (pos > map->eq || !map->next)
 510         return (retry_generic (menu, map->keys, pos, LastKey));
 511       map = map->next;
 512     }
 513
 514     if (LastKey != map->keys[pos])
 515       return (retry_generic (menu, map->keys, pos, LastKey));
 516
 517     if (++pos == map->len)
 518     {
 519
 520       if (map->op != OP_MACRO)
 521         return map->op;
 522
 523       if (n++ == 10)
 524       {
 525         mutt_flushinp ();
 526         mutt_error _("Macro loop detected.");
 527         return -1;
 528       }
 529
 530       push_string (map->macro);
 531       map = Keymaps[menu];
 532       pos = 0;
 533     }
 534   }
 535
 536   /* not reached */
 537 }
 538
 539 static void create_bindings (struct binding_t *map, int menu)
 540 {
 541   int i;
 542
 543   for (i = 0 ; map[i].name ; i++)
 544     if (map[i].seq)
 545       km_bindkey (map[i].seq, menu, map[i].op);
 546 }
 547
 548 char *km_keyname (int c)
 549 {
 550   static char buf[10];
 551   char *p;
 552
 553   if ((p = mutt_getnamebyvalue (c, KeyNames)))
 554     return p;
 555
 556   if (c < 256 && c > -128 && iscntrl ((unsigned char) c))
 557   {
 558     if (c < 0)
 559       c += 256;
 560
 561     if (c < 128)
 562     {
 563       buf[0] = '^';
 564       buf[1] = (c + '@') & 0x7f;
 565       buf[2] = 0;
 566     }
 567     else
 568       snprintf (buf, sizeof (buf), "\\%d%d%d", c >> 6, (c >> 3) & 7, c & 7);
 569   }
 570   else if (c >= KEY_F0 && c < KEY_F(256)) /* this maximum is just a guess */
 571     sprintf (buf, "<F%d>", c - KEY_F0);
 572   else if (IsPrint (c))
 573     snprintf (buf, sizeof (buf), "%c", (unsigned char) c);
 574   else
 575     snprintf (buf, sizeof (buf), "\\x%hx", (unsigned short) c);
 576   return (buf);
 577 }
 578
 579 int km_expand_key (char *s, size_t len, struct keymap_t *map)
 580 {
 581   size_t l;
 582   int p = 0;
 583
 584   if (!map)
 585     return (0);
 586
 587   FOREVER
 588   {
 589     strfcpy (s, km_keyname (map->keys[p]), len);
 590     len -= (l = mutt_strlen (s));
 591
 592     if (++p >= map->len || !len)
 593       return (1);
 594
 595     s += l;
 596   }
 597
 598   /* not reached */
 599 }
 600
 601 struct keymap_t *km_find_func (int menu, int func)
 602 {
 603   struct keymap_t *map = Keymaps[menu];
 604
 605   for (; map; map = map->next)
 606     if (map->op == func)
 607       break;
 608   return (map);
 609 }
 610
 611 #ifdef NCURSES_VERSION
 612 struct extkey {
 613   const char *name;
 614   const char *sym;
 615 };
 616
 617 static const struct extkey ExtKeys[] = {
 618   { "<c-up>", "kUP5" },
 619   { "<s-up>", "kUP" },
 620   { "<a-up>", "kUP3" },
 621
 622   { "<s-down>", "kDN" },
 623   { "<a-down>", "kDN3" },
 624   { "<c-down>", "kDN5" },
 625
 626   { "<c-right>", "kRIT5" },
 627   { "<s-right>", "kRIT" },
 628   { "<a-right>", "kRIT3" },
 629
 630   { "<s-left>", "kLFT" },
 631   { "<a-left>", "kLFT3" },
 632   { "<c-left>", "kLFT5" },
 633
 634   { "<s-home>", "kHOM" },
 635   { "<a-home>", "kHOM3" },
 636   { "<c-home>", "kHOM5" },
 637
 638   { "<s-end>", "kEND" },
 639   { "<a-end>", "kEND3" },
 640   { "<c-end>", "kEND5" },
 641
 642   { "<s-next>", "kNXT" },
 643   { "<a-next>", "kNXT3" },
 644   { "<c-next>", "kNXT5" },
 645
 646   { "<s-prev>", "kPRV" },
 647   { "<a-prev>", "kPRV3" },
 648   { "<c-prev>", "kPRV5" },
 649
 650   { 0, 0 }
 651 };
 652
 653 /* Look up Mutt's name for a key and find the ncurses extended name for it */
 654 static const char *find_ext_name(const char *key)
 655 {
 656   int j;
 657
 658   for (j = 0; ExtKeys[j].name; ++j)
 659   {
 660     if (strcasecmp(key, ExtKeys[j].name) == 0)
 661       return ExtKeys[j].sym;
 662   }
 663   return 0;
 664 }
 665 #endif /* NCURSES_VERSION */
 666
 667 /* Determine the keycodes for ncurses extended keys and fill in the KeyNames array.
 668  *
 669  * This function must be called *after* initscr(), or tigetstr() returns -1.  This
 670  * creates a bit of a chicken-and-egg problem because km_init() is called prior to
 671  * start_curses().  This means that the default keybindings can't include any of the
 672  * extended keys because they won't be defined until later.
 673  */
 674 void init_extended_keys(void)
 675 {
 676 #ifdef NCURSES_VERSION
 677   int j;
 678
 679   use_extended_names(TRUE);
 680
 681   for (j = 0; KeyNames[j].name; ++j)
 682   {
 683     if (KeyNames[j].value == -1)
 684     {
 685       const char *keyname = find_ext_name(KeyNames[j].name);
 686
 687       if (keyname)
 688       {
 689         char *s = tigetstr(keyname);
 690         if (s && (long)(s) != -1)
 691         {
 692           int code = key_defined(s);
 693           if (code > 0)
 694             KeyNames[j].value = code;
 695         }
 696       }
 697     }
 698   }
 699 #endif
 700 }
 701
 702 void km_init (void)
 703 {
 704   memset (Keymaps, 0, sizeof (struct keymap_t *) * MENU_MAX);
 705
 706   create_bindings (OpAttach, MENU_ATTACH);
 707   create_bindings (OpBrowser, MENU_FOLDER);
 708   create_bindings (OpCompose, MENU_COMPOSE);
 709   create_bindings (OpMain, MENU_MAIN);
 710   create_bindings (OpPager, MENU_PAGER);
 711   create_bindings (OpPost, MENU_POST);
 712   create_bindings (OpQuery, MENU_QUERY);
 713   create_bindings (OpAlias, MENU_ALIAS);
 714
 715
 716   if ((WithCrypto & APPLICATION_PGP))
 717     create_bindings (OpPgp, MENU_PGP);
 718
 719   if ((WithCrypto & APPLICATION_SMIME))
 720     create_bindings (OpSmime, MENU_SMIME);
 721
 722 #ifdef CRYPT_BACKEND_GPGME
 723   create_bindings (OpPgp, MENU_KEY_SELECT_PGP);
 724   create_bindings (OpSmime, MENU_KEY_SELECT_SMIME);
 725 #endif
 726
 727 #ifdef MIXMASTER
 728   create_bindings (OpMix, MENU_MIX);
 729
 730   km_bindkey ("<space>", MENU_MIX, OP_GENERIC_SELECT_ENTRY);
 731   km_bindkey ("h", MENU_MIX, OP_MIX_CHAIN_PREV);
 732   km_bindkey ("l", MENU_MIX, OP_MIX_CHAIN_NEXT);
 733 #endif
 734
 735   /* bindings for the line editor */
 736   create_bindings (OpEditor, MENU_EDITOR);
 737
 738   km_bindkey ("<up>", MENU_EDITOR, OP_EDITOR_HISTORY_UP);
 739   km_bindkey ("<down>", MENU_EDITOR, OP_EDITOR_HISTORY_DOWN);
 740   km_bindkey ("<left>", MENU_EDITOR, OP_EDITOR_BACKWARD_CHAR);
 741   km_bindkey ("<right>", MENU_EDITOR, OP_EDITOR_FORWARD_CHAR);
 742   km_bindkey ("<home>", MENU_EDITOR, OP_EDITOR_BOL);
 743   km_bindkey ("<end>", MENU_EDITOR, OP_EDITOR_EOL);
 744   km_bindkey ("<backspace>", MENU_EDITOR, OP_EDITOR_BACKSPACE);
 745   km_bindkey ("<delete>", MENU_EDITOR, OP_EDITOR_BACKSPACE);
 746   km_bindkey ("\177", MENU_EDITOR, OP_EDITOR_BACKSPACE);
 747
 748   /* generic menu keymap */
 749   create_bindings (OpGeneric, MENU_GENERIC);
 750
 751   km_bindkey ("<home>", MENU_GENERIC, OP_FIRST_ENTRY);
 752   km_bindkey ("<end>", MENU_GENERIC, OP_LAST_ENTRY);
 753   km_bindkey ("<pagedown>", MENU_GENERIC, OP_NEXT_PAGE);
 754   km_bindkey ("<pageup>", MENU_GENERIC, OP_PREV_PAGE);
 755   km_bindkey ("<right>", MENU_GENERIC, OP_NEXT_PAGE);
 756   km_bindkey ("<left>", MENU_GENERIC, OP_PREV_PAGE);
 757   km_bindkey ("<up>", MENU_GENERIC, OP_PREV_ENTRY);
 758   km_bindkey ("<down>", MENU_GENERIC, OP_NEXT_ENTRY);
 759   km_bindkey ("1", MENU_GENERIC, OP_JUMP);
 760   km_bindkey ("2", MENU_GENERIC, OP_JUMP);
 761   km_bindkey ("3", MENU_GENERIC, OP_JUMP);
 762   km_bindkey ("4", MENU_GENERIC, OP_JUMP);
 763   km_bindkey ("5", MENU_GENERIC, OP_JUMP);
 764   km_bindkey ("6", MENU_GENERIC, OP_JUMP);
 765   km_bindkey ("7", MENU_GENERIC, OP_JUMP);
 766   km_bindkey ("8", MENU_GENERIC, OP_JUMP);
 767   km_bindkey ("9", MENU_GENERIC, OP_JUMP);
 768
 769   km_bindkey ("<enter>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
 770
 771   /* Miscellaneous extra bindings */
 772
 773   km_bindkey (" ", MENU_MAIN, OP_DISPLAY_MESSAGE);
 774   km_bindkey ("<up>", MENU_MAIN, OP_MAIN_PREV_UNDELETED);
 775   km_bindkey ("<down>", MENU_MAIN, OP_MAIN_NEXT_UNDELETED);
 776   km_bindkey ("J", MENU_MAIN, OP_NEXT_ENTRY);
 777   km_bindkey ("K", MENU_MAIN, OP_PREV_ENTRY);
 778   km_bindkey ("x", MENU_MAIN, OP_EXIT);
 779
 780   km_bindkey ("<enter>", MENU_MAIN, OP_DISPLAY_MESSAGE);
 781
 782   km_bindkey ("x", MENU_PAGER, OP_EXIT);
 783   km_bindkey ("i", MENU_PAGER, OP_EXIT);
 784   km_bindkey ("<backspace>", MENU_PAGER, OP_PREV_LINE);
 785   km_bindkey ("<pagedown>", MENU_PAGER, OP_NEXT_PAGE);
 786   km_bindkey ("<pageup>", MENU_PAGER, OP_PREV_PAGE);
 787   km_bindkey ("<up>", MENU_PAGER, OP_MAIN_PREV_UNDELETED);
 788   km_bindkey ("<right>", MENU_PAGER, OP_MAIN_NEXT_UNDELETED);
 789   km_bindkey ("<down>", MENU_PAGER, OP_MAIN_NEXT_UNDELETED);
 790   km_bindkey ("<left>", MENU_PAGER, OP_MAIN_PREV_UNDELETED);
 791   km_bindkey ("<home>", MENU_PAGER, OP_PAGER_TOP);
 792   km_bindkey ("<end>", MENU_PAGER, OP_PAGER_BOTTOM);
 793   km_bindkey ("1", MENU_PAGER, OP_JUMP);
 794   km_bindkey ("2", MENU_PAGER, OP_JUMP);
 795   km_bindkey ("3", MENU_PAGER, OP_JUMP);
 796   km_bindkey ("4", MENU_PAGER, OP_JUMP);
 797   km_bindkey ("5", MENU_PAGER, OP_JUMP);
 798   km_bindkey ("6", MENU_PAGER, OP_JUMP);
 799   km_bindkey ("7", MENU_PAGER, OP_JUMP);
 800   km_bindkey ("8", MENU_PAGER, OP_JUMP);
 801   km_bindkey ("9", MENU_PAGER, OP_JUMP);
 802
 803   km_bindkey ("<enter>", MENU_PAGER, OP_NEXT_LINE);
 804
 805   km_bindkey ("<return>", MENU_ALIAS, OP_GENERIC_SELECT_ENTRY);
 806   km_bindkey ("<enter>",  MENU_ALIAS, OP_GENERIC_SELECT_ENTRY);
 807   km_bindkey ("<space>", MENU_ALIAS, OP_TAG);
 808
 809   km_bindkey ("<enter>", MENU_ATTACH, OP_VIEW_ATTACH);
 810   km_bindkey ("<enter>", MENU_COMPOSE, OP_VIEW_ATTACH);
 811
 812   /* edit-to (default "t") hides generic tag-entry in Compose menu
 813      This will bind tag-entry to  "T" in the Compose menu */
 814   km_bindkey ("T", MENU_COMPOSE, OP_TAG);
 815 }
 816
 817 void km_error_key (int menu)
 818 {
 819   char buf[SHORT_STRING];
 820   struct keymap_t *key;
 821
 822   if(!(key = km_find_func(menu, OP_HELP)))
 823     key = km_find_func(MENU_GENERIC, OP_HELP);
 824
 825   if(!(km_expand_key(buf, sizeof(buf), key)))
 826   {
 827     mutt_error _("Key is not bound.");
 828     return;
 829   }
 830
 831   /* make sure the key is really the help key in this menu */
 832   push_string (buf);
 833   if (km_dokey (menu) != OP_HELP)
 834   {
 835     mutt_error _("Key is not bound.");
 836     return;
 837   }
 838
 839   mutt_error (_("Key is not bound.  Press '%s' for help."), buf);
 840   return;
 841 }
 842
 843 int mutt_parse_push (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err)
 844 {
 845   int r = 0;
 846
 847   mutt_extract_token (buf, s, M_TOKEN_CONDENSE);
 848   if (MoreArgs (s))
 849   {
 850     strfcpy (err->data, _("push: too many arguments"), err->dsize);
 851     r = -1;
 852   }
 853   else
 854     push_string (buf->data);
 855   return (r);
 856 }
 857
 858 /* expects to see: <menu-string>,<menu-string>,... <key-string> */
 859 static char *parse_keymap (int *menu, BUFFER *s, int maxmenus, int *nummenus, BUFFER *err)
 860 {
 861   BUFFER buf;
 862   int i=0;
 863   char *p, *q;
 864
 865   memset (&buf, 0, sizeof (buf));
 866
 867   /* menu name */
 868   mutt_extract_token (&buf, s, 0);
 869   p = buf.data;
 870   if (MoreArgs (s))
 871   {
 872     while (i < maxmenus)
 873     {
 874       q = strchr(p,',');
 875       if (q)
 876         *q = '\0';
 877
 878       if ((menu[i] = mutt_check_menu (p)) == -1)
 879       {
 880          snprintf (err->data, err->dsize, _("%s: no such menu"), p);
 881          goto error;
 882       }
 883       ++i;
 884       if (q)
 885         p = q+1;
 886       else
 887         break;
 888     }
 889     *nummenus=i;
 890     /* key sequence */
 891     mutt_extract_token (&buf, s, 0);
 892
 893     if (!*buf.data)
 894     {
 895       strfcpy (err->data, _("null key sequence"), err->dsize);
 896     }
 897     else if (MoreArgs (s))
 898       return (buf.data);
 899   }
 900   else
 901   {
 902     strfcpy (err->data, _("too few arguments"), err->dsize);
 903   }
 904 error:
 905   FREE (&buf.data);
 906   return (NULL);
 907 }
 908
 909 static int
 910 try_bind (char *key, int menu, char *func, struct binding_t *bindings)
 911 {
 912   int i;
 913
 914   for (i = 0; bindings[i].name; i++)
 915     if (mutt_strcmp (func, bindings[i].name) == 0)
 916     {
 917       km_bindkey (key, menu, bindings[i].op);
 918       return (0);
 919     }
 920   return (-1);
 921 }
 922
 923 struct binding_t *km_get_table (int menu)
 924 {
 925   switch (menu)
 926   {
 927     case MENU_MAIN:
 928       return OpMain;
 929     case MENU_GENERIC:
 930       return OpGeneric;
 931     case MENU_COMPOSE:
 932       return OpCompose;
 933     case MENU_PAGER:
 934       return OpPager;
 935     case MENU_POST:
 936       return OpPost;
 937     case MENU_FOLDER:
 938       return OpBrowser;
 939     case MENU_ALIAS:
 940       return OpAlias;
 941     case MENU_ATTACH:
 942       return OpAttach;
 943     case MENU_EDITOR:
 944       return OpEditor;
 945     case MENU_QUERY:
 946       return OpQuery;
 947
 948     case MENU_PGP:
 949       return (WithCrypto & APPLICATION_PGP)? OpPgp:NULL;
 950
 951 #ifdef CRYPT_BACKEND_GPGME
 952     case MENU_KEY_SELECT_PGP:
 953       return OpPgp;
 954     case MENU_KEY_SELECT_SMIME:
 955       return OpSmime;
 956 #endif
 957
 958 #ifdef MIXMASTER
 959     case MENU_MIX:
 960       return OpMix;
 961 #endif
 962
 963   }
 964   return NULL;
 965 }
 966
 967 /* bind menu-name '<key_sequence>' function-name */
 968 int mutt_parse_bind (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err)
 969 {
 970   struct binding_t *bindings = NULL;
 971   char *key;
 972   int menu[sizeof(Menus)/sizeof(struct mapping_t)-1], r = 0, nummenus, i;
 973
 974   if ((key = parse_keymap (menu, s, sizeof (menu)/sizeof (menu[0]),
 975                            &nummenus, err)) == NULL)
 976     return (-1);
 977
 978   /* function to execute */
 979   mutt_extract_token (buf, s, 0);
 980   if (MoreArgs (s))
 981   {
 982     strfcpy (err->data, _("bind: too many arguments"), err->dsize);
 983     r = -1;
 984   }
 985   else if (ascii_strcasecmp ("noop", buf->data) == 0)
 986   {
 987     for (i = 0; i < nummenus; ++i)
 988     {
 989       km_bindkey (key, menu[i], OP_NULL); /* the `unbind' command */
 990     }
 991   }
 992   else
 993   {
 994     for (i = 0; i < nummenus; ++i)
 995     {
 996       /* First check the "generic" list of commands */
 997       if (menu[i] == MENU_PAGER || menu[i] == MENU_EDITOR ||
 998       menu[i] == MENU_GENERIC ||
 999           try_bind (key, menu[i], buf->data, OpGeneric) != 0)
1000       {
1001         /* Now check the menu-specific list of commands (if they exist) */
1002         bindings = km_get_table (menu[i]);
1003         if (bindings && try_bind (key, menu[i], buf->data, bindings) != 0)
1004         {
1005           snprintf (err->data, err->dsize, _("%s: no such function in map"), buf->data);
1006           r = -1;
1007         }
1008       }
1009     }
1010   }
1011   FREE (&key);
1012   return (r);
1013 }
1014
1015 /* macro <menu> <key> <macro> <description> */
1016 int mutt_parse_macro (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err)
1017 {
1018   int menu[sizeof(Menus)/sizeof(struct mapping_t)-1], r = -1, nummenus, i;
1019   char *seq = NULL;
1020   char *key;
1021
1022   if ((key = parse_keymap (menu, s, sizeof (menu) / sizeof (menu[0]), &nummenus, err)) == NULL)
1023     return (-1);
1024
1025   mutt_extract_token (buf, s, M_TOKEN_CONDENSE);
1026   /* make sure the macro sequence is not an empty string */
1027   if (!*buf->data)
1028   {
1029     strfcpy (err->data, _("macro: empty key sequence"), err->dsize);
1030   }
1031   else
1032   {
1033     if (MoreArgs (s))
1034     {
1035       seq = safe_strdup (buf->data);
1036       mutt_extract_token (buf, s, M_TOKEN_CONDENSE);
1037
1038       if (MoreArgs (s))
1039       {
1040         strfcpy (err->data, _("macro: too many arguments"), err->dsize);
1041       }
1042       else
1043       {
1044         for (i = 0; i < nummenus; ++i)
1045         {
1046           km_bind (key, menu[i], OP_MACRO, seq, buf->data);
1047           r = 0;
1048         }
1049       }
1050
1051       FREE (&seq);
1052     }
1053     else
1054     {
1055       for (i = 0; i < nummenus; ++i)
1056       {
1057         km_bind (key, menu[i], OP_MACRO, buf->data, NULL);
1058         r = 0;
1059       }
1060     }
1061   }
1062   FREE (&key);
1063   return (r);
1064 }
1065
1066 /* exec function-name */
1067 int mutt_parse_exec (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err)
1068 {
1069   int ops[128];
1070   int nops = 0;
1071   struct binding_t *bindings = NULL;
1072   char *function;
1073
1074   if (!MoreArgs (s))
1075   {
1076     strfcpy (err->data, _("exec: no arguments"), err->dsize);
1077     return (-1);
1078   }
1079
1080   do
1081   {
1082     mutt_extract_token (buf, s, 0);
1083     function = buf->data;
1084
1085     if ((bindings = km_get_table (CurrentMenu)) == NULL
1086         && CurrentMenu != MENU_PAGER)
1087       bindings = OpGeneric;
1088
1089     ops[nops] = get_op (bindings, function, mutt_strlen(function));
1090     if (ops[nops] == OP_NULL && CurrentMenu != MENU_PAGER)
1091       ops[nops] = get_op (OpGeneric, function, mutt_strlen(function));
1092
1093     if (ops[nops] == OP_NULL)
1094     {
1095       mutt_flushinp ();
1096       mutt_error (_("%s: no such function"), function);
1097       return (-1);
1098     }
1099     nops++;
1100   }
1101   while(MoreArgs(s) && nops < sizeof(ops)/sizeof(ops[0]));
1102
1103   while(nops)
1104     mutt_ungetch(0, ops[--nops]);
1105
1106   return 0;
1107 }
1108
1109 /*
1110  * prompts the user to enter a keystroke, and displays the octal value back
1111  * to the user.
1112  */
1113 void mutt_what_key (void)
1114 {
1115   int ch;
1116
1117   mvprintw(LINES-1,0, _("Enter keys (^G to abort): "));
1118   do {
1119     ch = getch();
1120     if (ch != ERR && ch != ctrl ('G'))
1121     {
1122       mutt_message(_("Char = %s, Octal = %o, Decimal = %d"),
1123                km_keyname(ch), ch, ch);
1124     }
1125   }
1126   while (ch != ERR && ch != ctrl ('G'));
1127
1128   mutt_flushinp();
1129   mutt_clear_error();
1130 }