contrib/tcsh-6/tc.bind.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/tc.bind.c,v 3.44 2006/03/02 18:46:44 christos Exp $ */
   2 /*
   3  * tc.bind.c: Key binding functions
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 #include "sh.h"
  34
  35 RCSID("$tcsh: tc.bind.c,v 3.44 2006/03/02 18:46:44 christos Exp $")
  36
  37 #include "ed.h"
  38 #include "ed.defns.h"
  39
  40 static  void   printkey         (const KEYCMD *, CStr *);
  41 static  KEYCMD parsecmd         (Char *);
  42 static  void   bad_spec         (const Char *);
  43 static  CStr  *parsestring      (const Char *, CStr *);
  44 static  CStr  *parsebind        (const Char *, CStr *);
  45 static  void   print_all_keys   (void);
  46 static  void   printkeys        (KEYCMD *, int, int);
  47 static  void   bindkey_usage    (void);
  48 static  void   list_functions   (void);
  49
  50 extern int MapsAreInited;
  51
  52
  53
  54
  55 /*ARGSUSED*/
  56 void
  57 dobindkey(Char **v, struct command *c)
  58 {
  59     KEYCMD *map;
  60     int     ntype, no, removeb, key, bindk;
  61     Char   *par;
  62     Char    p;
  63     KEYCMD  cmd;
  64     CStr    in;
  65     CStr    out;
  66     uChar   ch;
  67
  68     USE(c);
  69     if (!MapsAreInited)
  70         ed_InitMaps();
  71
  72     map = CcKeyMap;
  73     ntype = XK_CMD;
  74     key = removeb = bindk = 0;
  75     for (no = 1, par = v[no];
  76          par != NULL && (*par++ & CHAR) == '-'; no++, par = v[no]) {
  77         if ((p = (*par & CHAR)) == '-') {
  78             no++;
  79             break;
  80         }
  81         else
  82             switch (p) {
  83             case 'b':
  84                 bindk = 1;
  85                 break;
  86             case 'k':
  87                 key = 1;
  88                 break;
  89             case 'a':
  90                 map = CcAltMap;
  91                 break;
  92             case 's':
  93                 ntype = XK_STR;
  94                 break;
  95             case 'c':
  96                 ntype = XK_EXE;
  97                 break;
  98             case 'r':
  99                 removeb = 1;
 100                 break;
 101             case 'v':
 102                 ed_InitVIMaps();
 103                 return;
 104             case 'e':
 105                 ed_InitEmacsMaps();
 106                 return;
 107             case 'd':
 108 #ifdef VIDEFAULT
 109                 ed_InitVIMaps();
 110 #else /* EMACSDEFAULT */
 111                 ed_InitEmacsMaps();
 112 #endif /* VIDEFAULT */
 113                 return;
 114             case 'l':
 115                 list_functions();
 116                 return;
 117             default:
 118                 bindkey_usage();
 119                 return;
 120             }
 121     }
 122
 123     if (!v[no]) {
 124         print_all_keys();
 125         return;
 126     }
 127
 128     if (key) {
 129         if (!IsArrowKey(v[no]))
 130             xprintf(CGETS(20, 1, "Invalid key name `%S'\n"), v[no]);
 131         in.buf = Strsave(v[no++]);
 132         in.len = Strlen(in.buf);
 133     }
 134     else {
 135         if (bindk) {
 136             if (parsebind(v[no++], &in) == NULL)
 137                 return;
 138         }
 139         else {
 140             if (parsestring(v[no++], &in) == NULL)
 141                 return;
 142         }
 143     }
 144     cleanup_push(in.buf, xfree);
 145
 146 #ifndef WINNT_NATIVE
 147     if (in.buf[0] > 0xFF) {
 148         bad_spec(in.buf);
 149         cleanup_until(in.buf);
 150         return;
 151     }
 152 #endif
 153     ch = (uChar) in.buf[0];
 154
 155     if (removeb) {
 156         if (key)
 157             (void) ClearArrowKeys(&in);
 158         else if (in.len > 1) {
 159             (void) DeleteXkey(&in);
 160         }
 161         else if (map[ch] == F_XKEY) {
 162             (void) DeleteXkey(&in);
 163             map[ch] = F_UNASSIGNED;
 164         }
 165         else {
 166             map[ch] = F_UNASSIGNED;
 167         }
 168         cleanup_until(in.buf);
 169         return;
 170     }
 171     if (!v[no]) {
 172         if (key)
 173             PrintArrowKeys(&in);
 174         else
 175             printkey(map, &in);
 176         cleanup_until(in.buf);
 177         return;
 178     }
 179     if (v[no + 1]) {
 180         bindkey_usage();
 181         cleanup_until(in.buf);
 182         return;
 183     }
 184     switch (ntype) {
 185     case XK_STR:
 186     case XK_EXE:
 187         if (parsestring(v[no], &out) == NULL) {
 188             cleanup_until(in.buf);
 189             return;
 190         }
 191         cleanup_push(out.buf, xfree);
 192         if (key) {
 193             if (SetArrowKeys(&in, XmapStr(&out), ntype) == -1)
 194                 xprintf(CGETS(20, 2, "Bad key name: %S\n"), in.buf);
 195             else
 196                 cleanup_ignore(out.buf);
 197         }
 198         else
 199             AddXkey(&in, XmapStr(&out), ntype);
 200         map[ch] = F_XKEY;
 201         break;
 202     case XK_CMD:
 203         if ((cmd = parsecmd(v[no])) == 0) {
 204             cleanup_until(in.buf);
 205             return;
 206         }
 207         if (key)
 208             (void) SetArrowKeys(&in, XmapCmd((int) cmd), ntype);
 209         else {
 210             if (in.len > 1) {
 211                 AddXkey(&in, XmapCmd((int) cmd), ntype);
 212                 map[ch] = F_XKEY;
 213             }
 214             else {
 215                 ClearXkey(map, &in);
 216                 map[ch] = cmd;
 217             }
 218         }
 219         break;
 220     default:
 221         abort();
 222         break;
 223     }
 224     cleanup_until(in.buf);
 225     if (key)
 226         BindArrowKeys();
 227 }
 228
 229 static void
 230 printkey(const KEYCMD *map, CStr *in)
 231 {
 232     struct KeyFuncs *fp;
 233
 234     if (in->len < 2) {
 235         unsigned char *unparsed;
 236
 237         unparsed = unparsestring(in, STRQQ);
 238         cleanup_push(unparsed, xfree);
 239         for (fp = FuncNames; fp->name; fp++) {
 240             if (fp->func == map[(uChar) *(in->buf)]) {
 241                 xprintf("%s\t->\t%s\n", unparsed, fp->name);
 242             }
 243         }
 244         cleanup_until(unparsed);
 245     }
 246     else
 247         PrintXkey(in);
 248 }
 249
 250 static  KEYCMD
 251 parsecmd(Char *str)
 252 {
 253     struct KeyFuncs *fp;
 254
 255     for (fp = FuncNames; fp->name; fp++) {
 256         if (strcmp(short2str(str), fp->name) == 0) {
 257             return (KEYCMD) fp->func;
 258         }
 259     }
 260     xprintf(CGETS(20, 3, "Bad command name: %S\n"), str);
 261     return 0;
 262 }
 263
 264
 265 static void
 266 bad_spec(const Char *str)
 267 {
 268     xprintf(CGETS(20, 4, "Bad key spec %S\n"), str);
 269 }
 270
 271 static CStr *
 272 parsebind(const Char *s, CStr *str)
 273 {
 274     struct Strbuf b = Strbuf_INIT;
 275
 276     cleanup_push(&b, Strbuf_cleanup);
 277     if (Iscntrl(*s)) {
 278         Strbuf_append1(&b, *s);
 279         goto end;
 280     }
 281
 282     switch (*s) {
 283     case '^':
 284         s++;
 285 #ifdef IS_ASCII
 286         Strbuf_append1(&b, (*s == '?') ? '\177' : ((*s & CHAR) & 0237));
 287 #else
 288         Strbuf_append1(&b, (*s == '?') ? CTL_ESC('\177')
 289                        : _toebcdic[_toascii[*s & CHAR] & 0237]);
 290 #endif
 291         break;
 292
 293     case 'F':
 294     case 'M':
 295     case 'X':
 296     case 'C':
 297 #ifdef WINNT_NATIVE
 298     case 'N':
 299 #endif /* WINNT_NATIVE */
 300         if (s[1] != '-' || s[2] == '\0')
 301             goto bad_spec;
 302         s += 2;
 303         switch (s[-2]) {
 304         case 'F': case 'f':     /* Turn into ^[str */
 305             Strbuf_append1(&b, CTL_ESC('\033'));
 306             Strbuf_append(&b, s);
 307             break;
 308
 309         case 'C': case 'c':     /* Turn into ^c */
 310 #ifdef IS_ASCII
 311             Strbuf_append1(&b, (*s == '?') ? '\177' : ((*s & CHAR) & 0237));
 312 #else
 313             Strbuf_append1(&b, (*s == '?') ? CTL_ESC('\177')
 314                            : _toebcdic[_toascii[*s & CHAR] & 0237]);
 315 #endif
 316             break;
 317
 318         case 'X' : case 'x':    /* Turn into ^Xc */
 319 #ifdef IS_ASCII
 320             Strbuf_append1(&b, 'X' & 0237);
 321 #else
 322             Strbuf_append1(&b, _toebcdic[_toascii['X'] & 0237]);
 323 #endif
 324             Strbuf_append1(&b, *s);
 325             break;
 326
 327         case 'M' : case 'm':    /* Turn into 0x80|c */
 328             if (!NoNLSRebind) {
 329                 Strbuf_append1(&b, CTL_ESC('\033'));
 330                 Strbuf_append1(&b, *s);
 331             } else {
 332 #ifdef IS_ASCII
 333                 Strbuf_append1(&b, *s | 0x80);
 334 #else
 335                 Strbuf_append1(&b, _toebcdic[_toascii[*s] | 0x80]);
 336 #endif
 337             }
 338             break;
 339 #ifdef WINNT_NATIVE
 340         case 'N' : case 'n':    /* NT */
 341                 {
 342                         Char bnt;
 343
 344                         bnt = nt_translate_bindkey(s);
 345                         if (bnt != 0)
 346                                 Strbuf_append1(&b, bnt);
 347                         else
 348                                 bad_spec(s);
 349                 }
 350             break;
 351 #endif /* WINNT_NATIVE */
 352
 353         default:
 354             abort();
 355         }
 356         break;
 357
 358     default:
 359         goto bad_spec;
 360     }
 361
 362  end:
 363     cleanup_ignore(&b);
 364     cleanup_until(&b);
 365     Strbuf_terminate(&b);
 366     str->buf = xrealloc(b.s, (b.len + 1) * sizeof (*str->buf));
 367     str->len = b.len;
 368     return str;
 369
 370  bad_spec:
 371     bad_spec(s);
 372     cleanup_until(&b);
 373     return NULL;
 374 }
 375
 376
 377 static CStr *
 378 parsestring(const Char *str, CStr *buf)
 379 {
 380     struct Strbuf b = Strbuf_INIT;
 381     const Char   *p;
 382     eChar  es;
 383
 384     if (*str == 0) {
 385         xprintf(CGETS(20, 5, "Null string specification\n"));
 386         return NULL;
 387     }
 388
 389     cleanup_push(&b, Strbuf_cleanup);
 390     for (p = str; *p != 0; p++) {
 391         if ((*p & CHAR) == '\\' || (*p & CHAR) == '^') {
 392             if ((es = parseescape(&p)) == CHAR_ERR) {
 393                 cleanup_until(&b);
 394                 return 0;
 395             } else
 396                 Strbuf_append1(&b, es);
 397         }
 398         else
 399             Strbuf_append1(&b, *p & CHAR);
 400     }
 401     cleanup_ignore(&b);
 402     cleanup_until(&b);
 403     Strbuf_terminate(&b);
 404     buf->buf = xrealloc(b.s, (b.len + 1) * sizeof (*buf->buf));
 405     buf->len = b.len;
 406     return buf;
 407 }
 408
 409 static void
 410 print_all_keys(void)
 411 {
 412     int     prev, i;
 413     CStr nilstr;
 414     nilstr.buf = NULL;
 415     nilstr.len = 0;
 416
 417
 418     xprintf(CGETS(20, 6, "Standard key bindings\n"));
 419     prev = 0;
 420     for (i = 0; i < 256; i++) {
 421         if (CcKeyMap[prev] == CcKeyMap[i])
 422             continue;
 423         printkeys(CcKeyMap, prev, i - 1);
 424         prev = i;
 425     }
 426     printkeys(CcKeyMap, prev, i - 1);
 427
 428     xprintf(CGETS(20, 7, "Alternative key bindings\n"));
 429     prev = 0;
 430     for (i = 0; i < 256; i++) {
 431         if (CcAltMap[prev] == CcAltMap[i])
 432             continue;
 433         printkeys(CcAltMap, prev, i - 1);
 434         prev = i;
 435     }
 436     printkeys(CcAltMap, prev, i - 1);
 437     xprintf(CGETS(20, 8, "Multi-character bindings\n"));
 438     PrintXkey(NULL);    /* print all Xkey bindings */
 439     xprintf(CGETS(20, 9, "Arrow key bindings\n"));
 440     PrintArrowKeys(&nilstr);
 441 }
 442
 443 static void
 444 printkeys(KEYCMD *map, int first, int last)
 445 {
 446     struct KeyFuncs *fp;
 447     Char    firstbuf[2], lastbuf[2];
 448     CStr fb, lb;
 449     unsigned char *unparsed;
 450     fb.buf = firstbuf;
 451     lb.buf = lastbuf;
 452
 453     firstbuf[0] = (Char) first;
 454     firstbuf[1] = 0;
 455     lastbuf[0] = (Char) last;
 456     lastbuf[1] = 0;
 457     fb.len = 1;
 458     lb.len = 1;
 459
 460     unparsed = unparsestring(&fb, STRQQ);
 461     cleanup_push(unparsed, xfree);
 462     if (map[first] == F_UNASSIGNED) {
 463         if (first == last)
 464             xprintf(CGETS(20, 10, "%-15s->  is undefined\n"), unparsed);
 465         cleanup_until(unparsed);
 466         return;
 467     }
 468
 469     for (fp = FuncNames; fp->name; fp++) {
 470         if (fp->func == map[first]) {
 471             if (first == last)
 472                 xprintf("%-15s->  %s\n", unparsed, fp->name);
 473             else {
 474                 unsigned char *p;
 475
 476                 p = unparsestring(&lb, STRQQ);
 477                 cleanup_push(p, xfree);
 478                 xprintf("%-4s to %-7s->  %s\n", unparsed, p, fp->name);
 479             }
 480             cleanup_until(unparsed);
 481             return;
 482         }
 483     }
 484     xprintf(CGETS(20, 11, "BUG!!! %s isn't bound to anything.\n"), unparsed);
 485     if (map == CcKeyMap)
 486         xprintf("CcKeyMap[%d] == %d\n", first, CcKeyMap[first]);
 487     else
 488         xprintf("CcAltMap[%d] == %d\n", first, CcAltMap[first]);
 489     cleanup_until(unparsed);
 490 }
 491
 492 static void
 493 bindkey_usage(void)
 494 {
 495     xprintf(CGETS(20, 12,
 496             "Usage: bindkey [options] [--] [KEY [COMMAND]]\n"));
 497     xprintf(CGETS(20, 13,
 498             "    -a   list or bind KEY in alternative key map\n"));
 499     xprintf(CGETS(20, 14,
 500             "    -b   interpret KEY as a C-, M-, F- or X- key name\n"));
 501     xprintf(CGETS(20, 15,
 502             "    -s   interpret COMMAND as a literal string to be output\n"));
 503     xprintf(CGETS(20, 16,
 504             "    -c   interpret COMMAND as a builtin or external command\n"));
 505     xprintf(CGETS(20, 17,
 506             "    -v   bind all keys to vi bindings\n"));
 507     xprintf(CGETS(20, 18,
 508             "    -e   bind all keys to emacs bindings\n"));
 509     xprintf(CGETS(20, 19,
 510             "    -d   bind all keys to default editor's bindings\n"));
 511     xprintf(CGETS(20, 20,
 512             "    -l   list editor commands with descriptions\n"));
 513     xprintf(CGETS(20, 21,
 514             "    -r   remove KEY's binding\n"));
 515     xprintf(CGETS(20, 22,
 516             "    -k   interpret KEY as a symbolic arrow-key name\n"));
 517     xprintf(CGETS(20, 23,
 518             "    --   force a break from option processing\n"));
 519     xprintf(CGETS(20, 24,
 520             "    -u   (or any invalid option) this message\n"));
 521     xprintf("\n");
 522     xprintf(CGETS(20, 25,
 523             "Without KEY or COMMAND, prints all bindings\n"));
 524     xprintf(CGETS(20, 26,
 525             "Without COMMAND, prints the binding for KEY.\n"));
 526 }
 527
 528 static void
 529 list_functions(void)
 530 {
 531     struct KeyFuncs *fp;
 532
 533     for (fp = FuncNames; fp->name; fp++) {
 534         xprintf("%s\n          %s\n", fp->name, fp->desc);
 535     }
 536 }