![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis|
Return to tio.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 ! root 1: /* tio.c */ ! 2: ! 3: /* Author: ! 4: * Steve Kirkendall ! 5: * 16820 SW Tallac Way ! 6: * Beaverton, OR 97006 ! 7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda ! 8: */ ! 9: ! 10: ! 11: /* This file contains terminal I/O functions */ ! 12: ! 13: #include "config.h" ! 14: #if BSD || COHERENT ! 15: # include <setjmp.h> ! 16: #endif ! 17: #include <signal.h> ! 18: #include "vi.h" ! 19: ! 20: ! 21: /* This function reads in a line from the terminal. */ ! 22: int vgets(prompt, buf, bsize) ! 23: char prompt; /* the prompt character, or '\0' for none */ ! 24: char *buf; /* buffer into which the string is read */ ! 25: int bsize; /* size of the buffer */ ! 26: { ! 27: int len; /* how much we've read so far */ ! 28: int ch; /* a character from the user */ ! 29: int quoted; /* is the next char quoted? */ ! 30: int tab; /* column position of cursor */ ! 31: char widths[132]; /* widths of characters */ ! 32: #ifndef NO_DIGRAPH ! 33: int erased; /* 0, or first char of a digraph */ ! 34: #endif ! 35: ! 36: /* show the prompt */ ! 37: move(LINES - 1, 0); ! 38: tab = 0; ! 39: if (prompt) ! 40: { ! 41: addch(prompt); ! 42: tab = 1; ! 43: } ! 44: clrtoeol(); ! 45: refresh(); ! 46: ! 47: /* read in the line */ ! 48: #ifndef NO_DIGRAPH ! 49: erased = ! 50: #endif ! 51: quoted = len = 0; ! 52: for (;;) ! 53: { ! 54: ch = getkey(quoted ? 0 : WHEN_EX); ! 55: ! 56: /* some special conversions */ ! 57: if (ch == ctrl('D') && len == 0) ! 58: ch = ctrl('['); ! 59: #ifndef NO_DIGRAPH ! 60: if (*o_digraph && erased != 0 && ch != '\b') ! 61: { ! 62: ch = digraph(erased, ch); ! 63: erased = 0; ! 64: } ! 65: #endif ! 66: ! 67: /* inhibit detection of special chars (except ^J) after a ^V */ ! 68: if (quoted && ch != '\n') ! 69: { ! 70: ch |= 256; ! 71: } ! 72: ! 73: /* process the character */ ! 74: switch(ch) ! 75: { ! 76: case ctrl('V'): ! 77: qaddch('^'); ! 78: qaddch('\b'); ! 79: quoted = TRUE; ! 80: break; ! 81: ! 82: case ctrl('['): ! 83: return -1; ! 84: ! 85: case '\n': ! 86: #if OSK ! 87: case '\l': ! 88: #else ! 89: case '\r': ! 90: #endif ! 91: clrtoeol(); ! 92: goto BreakBreak; ! 93: ! 94: case '\b': ! 95: if (len > 0) ! 96: { ! 97: len--; ! 98: #ifndef NO_DIGRAPH ! 99: erased = buf[len]; ! 100: #endif ! 101: for (ch = widths[len]; ch > 0; ch--) ! 102: addch('\b'); ! 103: if (mode == MODE_EX) ! 104: { ! 105: clrtoeol(); ! 106: } ! 107: tab -= widths[len]; ! 108: } ! 109: else ! 110: { ! 111: return -1; ! 112: } ! 113: break; ! 114: ! 115: default: ! 116: /* strip off quotation bit */ ! 117: if (ch & 256) ! 118: { ! 119: ch &= ~256; ! 120: quoted = FALSE; ! 121: qaddch(' '); ! 122: qaddch('\b'); ! 123: } ! 124: /* add & echo the char */ ! 125: if (len < bsize - 1) ! 126: { ! 127: if (ch == '\t') ! 128: { ! 129: widths[len] = *o_tabstop - (tab % *o_tabstop); ! 130: addstr(" " + 8 - widths[len]); ! 131: tab += widths[len]; ! 132: } ! 133: else if (ch > 0 && ch < ' ') /* > 0 by GB */ ! 134: { ! 135: addch('^'); ! 136: addch(ch + '@'); ! 137: widths[len] = 2; ! 138: tab += 2; ! 139: } ! 140: else if (ch == '\177') ! 141: { ! 142: addch('^'); ! 143: addch('?'); ! 144: widths[len] = 2; ! 145: tab += 2; ! 146: } ! 147: else ! 148: { ! 149: addch(ch); ! 150: widths[len] = 1; ! 151: tab++; ! 152: } ! 153: buf[len++] = ch; ! 154: } ! 155: else ! 156: { ! 157: beep(); ! 158: } ! 159: } ! 160: } ! 161: BreakBreak: ! 162: refresh(); ! 163: buf[len] = '\0'; ! 164: return len; ! 165: } ! 166: ! 167: ! 168: /* ring the terminal's bell */ ! 169: void beep() ! 170: { ! 171: if (*o_vbell) ! 172: { ! 173: do_VB(); ! 174: refresh(); ! 175: } ! 176: else if (*o_errorbells) ! 177: { ! 178: ttywrite("\007", 1); ! 179: } ! 180: } ! 181: ! 182: static int manymsgs; /* This variable keeps msgs from overwriting each other */ ! 183: static char pmsg[80]; /* previous message (waiting to be displayed) */ ! 184: ! 185: ! 186: static int showmsg() ! 187: { ! 188: /* if there is no message to show, then don't */ ! 189: if (!manymsgs) ! 190: return FALSE; ! 191: ! 192: /* display the message */ ! 193: move(LINES - 1, 0); ! 194: if (*pmsg) ! 195: { ! 196: standout(); ! 197: qaddch(' '); ! 198: qaddstr(pmsg); ! 199: qaddch(' '); ! 200: standend(); ! 201: } ! 202: clrtoeol(); ! 203: ! 204: manymsgs = FALSE; ! 205: return TRUE; ! 206: } ! 207: ! 208: ! 209: void endmsgs() ! 210: { ! 211: if (manymsgs) ! 212: { ! 213: showmsg(); ! 214: addch('\n'); ! 215: } ! 216: } ! 217: ! 218: /* Write a message in an appropriate way. This should really be a varargs ! 219: * function, but there is no such thing as vwprintw. Hack!!! ! 220: * ! 221: * In MODE_EX or MODE_COLON, the message is written immediately, with a ! 222: * newline at the end. ! 223: * ! 224: * In MODE_VI, the message is stored in a character buffer. It is not ! 225: * displayed until getkey() is called. msg() will call getkey() itself, ! 226: * if necessary, to prevent messages from being lost. ! 227: * ! 228: * msg("") - clears the message line ! 229: * msg("%s %d", ...) - does a printf onto the message line ! 230: */ ! 231: /*VARARGS1*/ ! 232: void msg(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7) ! 233: char *fmt; ! 234: long arg1, arg2, arg3, arg4, arg5, arg6, arg7; ! 235: { ! 236: if (mode != MODE_VI) ! 237: { ! 238: sprintf(pmsg, fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7); ! 239: qaddstr(pmsg); ! 240: addch('\n'); ! 241: exrefresh(); ! 242: } ! 243: else ! 244: { ! 245: /* wait for keypress between consecutive msgs */ ! 246: if (manymsgs) ! 247: { ! 248: getkey(WHEN_MSG); ! 249: } ! 250: ! 251: /* real message */ ! 252: sprintf(pmsg, fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7); ! 253: manymsgs = TRUE; ! 254: } ! 255: } ! 256: ! 257: ! 258: /* This function calls refresh() if the option exrefresh is set */ ! 259: void exrefresh() ! 260: { ! 261: char *scan; ! 262: ! 263: /* If this ex command wrote ANYTHING set exwrote so vi's : command ! 264: * can tell that it must wait for a user keystroke before redrawing. ! 265: */ ! 266: for (scan=kbuf; scan<stdscr; scan++) ! 267: if (*scan == '\n') ! 268: exwrote = TRUE; ! 269: ! 270: #if MICROSOFT /* avoid compiler bug */ ! 271: scan = stdscr; ! 272: #define stdscr scan ! 273: #endif ! 274: /* now we do the refresh thing */ ! 275: if (*o_exrefresh) ! 276: { ! 277: refresh(); ! 278: } ! 279: else ! 280: { ! 281: wqrefresh(stdscr); ! 282: } ! 283: #if MICROSOFT ! 284: #undef stdscr ! 285: stdscr = scan; ! 286: #endif ! 287: if (mode != MODE_VI) ! 288: { ! 289: manymsgs = FALSE; ! 290: } ! 291: } ! 292: ! 293: ! 294: ! 295: /* These are used for typeahead, and also for fudging the visual @ command */ ! 296: static char keybuf[100]; /* array of already-read keys */ ! 297: static int nkeys; /* total number of keys in keybuf */ ! 298: static int next; /* index of next key to return */ ! 299: #ifndef NO_AT ! 300: static int atnext; /* index of next key for "@", or 0 normally */ ! 301: int fromcutbuf(cbname) ! 302: int cbname; ! 303: { ! 304: int len; ! 305: ! 306: /* fail if we're already doing an @ macro */ ! 307: if (atnext > 0 && keybuf[atnext]) ! 308: { ! 309: msg("Can't nest @ commands"); ! 310: return FALSE; ! 311: } ! 312: ! 313: /* use the empty portion of keybuf[] to get chars from the cut buffer */ ! 314: len = cb2str(cbname, keybuf + nkeys, sizeof keybuf - nkeys); ! 315: if (len < 0) ! 316: { ! 317: msg("Invalid cut buffer name. Must be a-z"); ! 318: return FALSE; ! 319: } ! 320: if (len == 0) ! 321: { ! 322: msg("Cut buffer \"%c is empty", cbname); ! 323: return FALSE; ! 324: } ! 325: else if (len >= sizeof keybuf - nkeys) ! 326: { ! 327: msg("Cut buffer \"%c is too large to execute", cbname); ! 328: return FALSE; ! 329: } ! 330: ! 331: /* prepare to "read" those keys on subsequent getkey() calls */ ! 332: atnext = nkeys; ! 333: return TRUE; ! 334: } ! 335: #endif ! 336: ! 337: /* This array describes mapped key sequences */ ! 338: static struct _keymap ! 339: { ! 340: char *name; /* name of the key, or NULL */ ! 341: char rawin[LONGKEY]; /* the unmapped version of input */ ! 342: char cooked[80]; /* the mapped version of input */ ! 343: int len; /* length of the unmapped version */ ! 344: int when; /* when is this key mapped? */ ! 345: } ! 346: mapped[MAXMAPS]; ! 347: ! 348: #if !MSDOS && !TOS ! 349: # if BSD || COHERENT ! 350: static jmp_buf env_timeout; ! 351: static int dummy() ! 352: { ! 353: longjmp(env_timeout, 1); ! 354: return 0; ! 355: } ! 356: # else ! 357: static int dummy() ! 358: { ! 359: } ! 360: # endif ! 361: #endif ! 362: ! 363: /* This function reads in a keystroke for VI mode. It automatically handles ! 364: * key mapping. ! 365: */ ! 366: int getkey(when) ! 367: int when; /* which bits must be ON? */ ! 368: { ! 369: static char *cooked; /* rawin, or pointer to converted key */ ! 370: static int oldwhen; /* "when" from last time */ ! 371: static int oldleft; ! 372: static long oldtop; ! 373: static long oldnlines; ! 374: static char *cshape; /* current cursor shape */ ! 375: REG char *kptr; /* &keybuf[next] */ ! 376: REG struct _keymap *km; /* used to count through keymap */ ! 377: REG int i, j, k; ! 378: ! 379: #ifdef DEBUG ! 380: watch(); ! 381: #endif ! 382: ! 383: /* if this key is needed for delay between multiple error messages, ! 384: * then reset the manymsgs flag and abort any mapped key sequence. ! 385: */ ! 386: if (showmsg()) ! 387: { ! 388: if (when == WHEN_MSG) ! 389: { ! 390: qaddstr("[More...]"); ! 391: refresh(); ! 392: cooked = (char *)0; ! 393: } ! 394: else if (when == WHEN_VIINP || when == WHEN_VIREP) ! 395: { ! 396: redraw(cursor, TRUE); ! 397: } ! 398: } ! 399: ! 400: #ifndef NO_AT ! 401: /* if we're in the middle of a visual @ macro, take atnext */ ! 402: if (atnext > 0) ! 403: { ! 404: if (keybuf[atnext]) ! 405: { ! 406: return keybuf[atnext++]; ! 407: } ! 408: atnext = 0; ! 409: } ! 410: #endif ! 411: ! 412: /* if we're doing a mapped key, get the next char */ ! 413: if (cooked && *cooked) ! 414: { ! 415: return *cooked++; ! 416: } ! 417: ! 418: /* if keybuf is empty, fill it */ ! 419: if (next == nkeys) ! 420: { ! 421: #ifndef NO_CURSORSHAPE ! 422: /* make sure the cursor is the right shape */ ! 423: if (has_CQ) ! 424: { ! 425: cooked = cshape; ! 426: switch (when) ! 427: { ! 428: case WHEN_EX: cooked = CX; break; ! 429: case WHEN_VICMD: cooked = CV; break; ! 430: case WHEN_VIINP: cooked = CI; break; ! 431: case WHEN_VIREP: cooked = CR; break; ! 432: } ! 433: if (cooked != cshape) ! 434: { ! 435: cshape = cooked; ! 436: switch (when) ! 437: { ! 438: case WHEN_EX: do_CX(); break; ! 439: case WHEN_VICMD: do_CV(); break; ! 440: case WHEN_VIINP: do_CI(); break; ! 441: case WHEN_VIREP: do_CR(); break; ! 442: } ! 443: } ! 444: cooked = (char *)0; ! 445: } ! 446: #endif ! 447: ! 448: #ifndef NO_SHOWMODE ! 449: /* if "showmode" then say which mode we're in */ ! 450: if (*o_smd ! 451: && mode == MODE_VI ! 452: && (when != oldwhen || topline != oldtop || leftcol != oldleft || nlines != oldnlines)) ! 453: { ! 454: oldwhen = when; ! 455: oldtop = topline; ! 456: oldleft = leftcol; ! 457: oldnlines = nlines; ! 458: ! 459: if (when & WHEN_VICMD) ! 460: { ! 461: redraw(cursor, FALSE); ! 462: move(LINES - 1, COLS - 10); ! 463: standout(); ! 464: addstr("Command"); ! 465: standend(); ! 466: redraw(cursor, FALSE); ! 467: } ! 468: else if (when & WHEN_VIINP) ! 469: { ! 470: redraw(cursor, TRUE); ! 471: move(LINES - 1, COLS - 10); ! 472: standout(); ! 473: addstr(" Input "); ! 474: standend(); ! 475: redraw(cursor, TRUE); ! 476: } ! 477: else if (when & WHEN_VIREP) ! 478: { ! 479: redraw(cursor, TRUE); ! 480: move(LINES - 1, COLS - 10); ! 481: standout(); ! 482: addstr("Replace"); ! 483: standend(); ! 484: redraw(cursor, TRUE); ! 485: } ! 486: } ! 487: else ! 488: #endif ! 489: ! 490: /* redraw if getting a VI command */ ! 491: if (when & WHEN_VICMD) ! 492: { ! 493: redraw(cursor, FALSE); ! 494: } ! 495: ! 496: /* read the rawin keystrokes */ ! 497: refresh(); ! 498: while ((nkeys = ttyread(keybuf, sizeof keybuf)) < 0) ! 499: { ! 500: /* terminal was probably resized */ ! 501: *o_lines = LINES; ! 502: *o_columns = COLS; ! 503: if (when & (WHEN_VICMD|WHEN_VIINP|WHEN_VIREP)) ! 504: { ! 505: redraw(MARK_UNSET, FALSE); ! 506: redraw(cursor, (when & WHEN_VICMD) == 0); ! 507: refresh(); ! 508: } ! 509: } ! 510: next = 0; ! 511: ! 512: /* if nkeys == 0 then we've reached EOF of an ex script. */ ! 513: if (nkeys == 0) ! 514: { ! 515: tmpabort(TRUE); ! 516: move(LINES - 1, 0); ! 517: clrtoeol(); ! 518: refresh(); ! 519: endwin(); ! 520: exit(1); ! 521: } ! 522: } ! 523: ! 524: /* see how many mapped keys this might be */ ! 525: kptr = &keybuf[next]; ! 526: for (i = j = 0, k = -1, km = mapped; i < MAXMAPS; i++, km++) ! 527: { ! 528: if ((km->when & when) && km->len > 0 && *km->rawin == *kptr) ! 529: { ! 530: if (km->len > nkeys - next) ! 531: { ! 532: if (!strncmp(km->rawin, kptr, nkeys - next)) ! 533: { ! 534: j++; ! 535: } ! 536: } ! 537: else ! 538: { ! 539: if (!strncmp(km->rawin, kptr, km->len)) ! 540: { ! 541: j++; ! 542: k = i; ! 543: } ! 544: } ! 545: } ! 546: } ! 547: ! 548: /* if more than one, try to read some more */ ! 549: while (j > 1) ! 550: { ! 551: #if BSD || COHERENT ! 552: if (setjmp(env_timeout)) ! 553: { ! 554: /* we timed out - assume no mapping */ ! 555: j = 0; ! 556: break; ! 557: } ! 558: #endif ! 559: #if ANY_UNIX ! 560: signal(SIGALRM, dummy); ! 561: #endif ! 562: #if OSK ! 563: signal(SIGQUIT, dummy); ! 564: #endif ! 565: alarm((unsigned)*o_keytime); ! 566: i = nkeys; ! 567: if ((k = ttyread(keybuf + nkeys, sizeof keybuf - nkeys)) >= 0) ! 568: { ! 569: nkeys += k; ! 570: } ! 571: alarm(0); ! 572: #if OSK ! 573: # ifndef DEBUG ! 574: signal(SIGQUIT, SIG_IGN); ! 575: # endif ! 576: #endif ! 577: ! 578: /* if we couldn't read any more, pretend 0 mapped keys */ ! 579: if (i == nkeys) ! 580: { ! 581: j = 0; ! 582: } ! 583: else /* else we got some more - try again */ ! 584: { ! 585: for (i = j = 0, k = -1, km = mapped; i < MAXMAPS; i++, km++) ! 586: { ! 587: if ((km->when & when) && km->len > 0 && *km->rawin == *kptr) ! 588: { ! 589: if (km->len > nkeys - next) ! 590: { ! 591: if (!strncmp(km->rawin, kptr, nkeys - next)) ! 592: { ! 593: j++; ! 594: } ! 595: } ! 596: else ! 597: { ! 598: if (!strncmp(km->rawin, kptr, km->len)) ! 599: { ! 600: j++; ! 601: k = i; ! 602: } ! 603: } ! 604: } ! 605: } ! 606: } ! 607: } ! 608: ! 609: /* if unambiguously mapped key, use it! */ ! 610: if (j == 1 && k >= 0) ! 611: { ! 612: next += mapped[k].len; ! 613: cooked = mapped[k].cooked; ! 614: #ifndef NO_EXTENSIONS ! 615: if ((when & (WHEN_VIINP|WHEN_VIREP)) ! 616: && (mapped[k].when & WHEN_INMV)) ! 617: { ! 618: return 0; /* special case, means "a movement char follows" */ ! 619: } ! 620: else ! 621: #endif ! 622: { ! 623: return *cooked++; ! 624: } ! 625: } ! 626: else ! 627: /* assume key is unmapped, but still translate weird erase key to '\b' */ ! 628: if (keybuf[next] == ERASEKEY && when != 0) ! 629: { ! 630: next++; ! 631: return '\b'; ! 632: } ! 633: else if (keybuf[next] == '\0') ! 634: { ! 635: next++; ! 636: return ('A' & 0x1f); ! 637: } ! 638: else ! 639: { ! 640: return keybuf[next++]; ! 641: } ! 642: } ! 643: ! 644: ! 645: /* This function maps or unmaps a key */ ! 646: void mapkey(rawin, cooked, when, name) ! 647: char *rawin; /* the input key sequence, before mapping */ ! 648: char *cooked;/* after mapping */ ! 649: short when; /* bitmap of when mapping should happen */ ! 650: char *name; /* name of the key, if any */ ! 651: { ! 652: int i, j; ! 653: ! 654: #ifndef NO_EXTENSIONS ! 655: /* if the mapped version starts with the word "visual" then set WHEN_INMV */ ! 656: if (!strncmp(cooked, "visual ", 7)) ! 657: { ! 658: when |= WHEN_INMV; ! 659: cooked += 7; ! 660: } ! 661: /* if WHEN_INMV is set, then WHEN_VIINP and WHEN_VIREP must be set */ ! 662: if (when & WHEN_INMV) ! 663: { ! 664: when |= (WHEN_VIINP | WHEN_VIREP); ! 665: } ! 666: #endif ! 667: ! 668: /* see if the key sequence was mapped before */ ! 669: j = strlen(rawin); ! 670: for (i = 0; i < MAXMAPS; i++) ! 671: { ! 672: if (mapped[i].len == j ! 673: && !strncmp(mapped[i].rawin, rawin, j) ! 674: && (mapped[i].when & when)) ! 675: { ! 676: break; ! 677: } ! 678: } ! 679: ! 680: /* if not already mapped, then try to find a new slot to use */ ! 681: if (i == MAXMAPS) ! 682: { ! 683: for (i = 0; i < MAXMAPS && mapped[i].len > 0; i++) ! 684: { ! 685: } ! 686: } ! 687: ! 688: /* no room for the new key? */ ! 689: if (i == MAXMAPS) ! 690: { ! 691: msg("No room left in the key map table"); ! 692: return; ! 693: } ! 694: ! 695: /* map the key */ ! 696: if (cooked && *cooked) ! 697: { ! 698: /* Map the key */ ! 699: mapped[i].len = j; ! 700: strncpy(mapped[i].rawin, rawin, j); ! 701: strcpy(mapped[i].cooked, cooked); ! 702: mapped[i].when = when; ! 703: mapped[i].name = name; ! 704: } ! 705: else /* unmap the key */ ! 706: { ! 707: mapped[i].len = 0; ! 708: } ! 709: } ! 710: ! 711: /* Dump keys of a given type - WHEN_VICMD dumps the ":map" keys, and ! 712: * WHEN_VIINP|WHEN_VIREP dumps the ":map!" keys ! 713: */ ! 714: void dumpkey(when) ! 715: int when; /* WHEN_XXXX of mappings to be dumped */ ! 716: { ! 717: int i, len, mlen; ! 718: char *scan; ! 719: char *mraw; ! 720: ! 721: for (i = 0; i < MAXMAPS; i++) ! 722: { ! 723: /* skip unused entries, or entries that don't match "when" */ ! 724: if (mapped[i].len <= 0 || !(mapped[i].when & when)) ! 725: { ! 726: continue; ! 727: } ! 728: ! 729: /* dump the key label, if any */ ! 730: len = 8; ! 731: if (mapped[i].name) ! 732: { ! 733: qaddstr(mapped[i].name); ! 734: len -= strlen(mapped[i].name); ! 735: } ! 736: do ! 737: { ! 738: qaddch(' '); ! 739: } while (len-- > 0); ! 740: ! 741: /* dump the raw version */ ! 742: len = 0; ! 743: mlen = mapped[i].len; ! 744: mraw = mapped[i].rawin; ! 745: for (scan = mraw; scan < mraw + mlen; scan++) ! 746: { ! 747: if (UCHAR(*scan) < ' ' || *scan == '\177') ! 748: { ! 749: qaddch('^'); ! 750: qaddch(*scan ^ '@'); ! 751: len += 2; ! 752: } ! 753: else ! 754: { ! 755: qaddch(*scan); ! 756: len++; ! 757: } ! 758: } ! 759: do ! 760: { ! 761: qaddch(' '); ! 762: } while (++len < 8); ! 763: ! 764: /* dump the mapped version */ ! 765: #ifndef NO_EXTENSIONS ! 766: if ((mapped[i].when & WHEN_INMV) && (when & (WHEN_VIINP|WHEN_VIREP))) ! 767: { ! 768: qaddstr("visual "); ! 769: } ! 770: #endif ! 771: for (scan = mapped[i].cooked; *scan; scan++) ! 772: { ! 773: if (UCHAR(*scan) < ' ' || *scan == '\177') ! 774: { ! 775: qaddch('^'); ! 776: qaddch(*scan ^ '@'); ! 777: } ! 778: else ! 779: { ! 780: qaddch(*scan); ! 781: } ! 782: } ! 783: ! 784: addch('\n'); ! 785: exrefresh(); ! 786: } ! 787: } ! 788: ! 789: ! 790: ! 791: #ifndef MKEXRC ! 792: /* This function saves the current configuration of mapped keys to a file */ ! 793: void savekeys(fd) ! 794: int fd; /* file descriptor to save them to */ ! 795: { ! 796: int i; ! 797: char buf[80]; ! 798: ! 799: /* now write a map command for each key other than the arrows */ ! 800: for (i = 0; i < MAXMAPS; i++) ! 801: { ! 802: /* ignore keys that came from termcap */ ! 803: if (mapped[i].name) ! 804: { ! 805: continue; ! 806: } ! 807: ! 808: /* If this isn't used, ignore it */ ! 809: if (mapped[i].len <= 0) ! 810: { ! 811: continue; ! 812: } ! 813: ! 814: /* write the map command */ ! 815: #ifndef NO_EXTENSIONS ! 816: if (mapped[i].when & WHEN_INMV) ! 817: { ! 818: #if OSK ! 819: char fmt[80]; ! 820: sprintf(fmt, "map%%s %%.%ds %%s\n", mapped[i].len); ! 821: sprintf(buf, fmt, ! 822: (mapped[i].when & WHEN_VICMD) ? "" : "!", ! 823: #else ! 824: sprintf(buf, "map%s %.*s visual %s\n", ! 825: (mapped[i].when & WHEN_VICMD) ? "" : "!", ! 826: mapped[i].len, ! 827: #endif ! 828: mapped[i].rawin, ! 829: mapped[i].cooked); ! 830: twrite(fd, buf, strlen(buf)); ! 831: } ! 832: else ! 833: #endif ! 834: { ! 835: if (mapped[i].when & WHEN_VICMD) ! 836: { ! 837: #if OSK ! 838: char fmt[80]; ! 839: sprintf(fmt, "map %%.%ds %%s\n", mapped[i].len); ! 840: sprintf(buf, fmt, ! 841: #else ! 842: sprintf(buf, "map %.*s %s\n", mapped[i].len, ! 843: #endif ! 844: mapped[i].rawin, ! 845: mapped[i].cooked); ! 846: twrite(fd, buf, strlen(buf)); ! 847: } ! 848: if (mapped[i].when & (WHEN_VIINP | WHEN_VIREP)) ! 849: { ! 850: #if OSK ! 851: char fmt[80]; ! 852: sprintf(fmt, "map! %%.%ds %%s\n", mapped[i].len); ! 853: sprintf(buf, fmt, ! 854: #else ! 855: sprintf(buf, "map! %.*s %s\n", mapped[i].len, ! 856: #endif ! 857: mapped[i].rawin, ! 858: mapped[i].cooked); ! 859: twrite(fd, buf, strlen(buf)); ! 860: } ! 861: } ! 862: } ! 863: } ! 864: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.