![[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 / g / usr / bin / vi|
Return to tio.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 ! root 1: /* tio.c */ ! 2: ! 3: /* Author: ! 4: * Steve Kirkendall ! 5: * 14407 SW Teal Blvd. #C ! 6: * Beaverton, OR 97005 ! 7: * [email protected] ! 8: */ ! 9: ! 10: ! 11: /* This file contains terminal I/O functions */ ! 12: ! 13: #include "config.h" ! 14: #include "vi.h" ! 15: #include "ctype.h" ! 16: ! 17: static int showmsg P_((void)); ! 18: ! 19: /* This function reads in a line from the terminal. */ ! 20: int vgets(prompt, buf, bsize) ! 21: int prompt; /* the prompt character, or '\0' for none */ ! 22: char *buf; /* buffer into which the string is read */ ! 23: int bsize; /* size of the buffer */ ! 24: { ! 25: int len; /* how much we've read so far */ ! 26: int ch; /* a character from the user */ ! 27: int quoted; /* is the next char quoted? */ ! 28: int tab; /* column position of cursor */ ! 29: char widths[132]; /* widths of characters */ ! 30: int word; /* index of first letter of word */ ! 31: #ifndef NO_DIGRAPH ! 32: int erased; /* 0, or first char of a digraph */ ! 33: #endif ! 34: ! 35: /* show the prompt */ ! 36: move(LINES - 1, 0); ! 37: tab = 0; ! 38: if (prompt) ! 39: { ! 40: addch(prompt); ! 41: tab = 1; ! 42: } ! 43: clrtoeol(); ! 44: refresh(); ! 45: ! 46: /* read in the line */ ! 47: #ifndef NO_DIGRAPH ! 48: erased = ! 49: #endif ! 50: quoted = len = 0; ! 51: for (;;) ! 52: { ! 53: #ifndef NO_ABBR ! 54: if (quoted || mode == MODE_EX) ! 55: { ! 56: ch = getkey(0); ! 57: } ! 58: else ! 59: { ! 60: /* maybe expand an abbreviation while getting key */ ! 61: for (word = len; --word >= 0 && isalnum(buf[word]); ) ! 62: { ! 63: } ! 64: word++; ! 65: ch = getabkey(WHEN_EX, &buf[word], len - word); ! 66: } ! 67: #else ! 68: ch = getkey(0); ! 69: #endif ! 70: #ifndef NO_EXTENSIONS ! 71: if (ch == ctrl('O')) ! 72: { ! 73: ch = getkey(quoted ? 0 : WHEN_EX); ! 74: } ! 75: #endif ! 76: ! 77: /* some special conversions */ ! 78: if (ch == ctrl('D') && len == 0) ! 79: ch = ctrl('['); ! 80: #ifndef NO_DIGRAPH ! 81: if (*o_digraph && erased != 0 && ch != '\b') ! 82: { ! 83: ch = digraph(erased, ch); ! 84: erased = 0; ! 85: } ! 86: #endif ! 87: ! 88: /* inhibit detection of special chars (except ^J) after a ^V */ ! 89: if (quoted && ch != '\n') ! 90: { ! 91: ch |= 256; ! 92: } ! 93: ! 94: /* process the character */ ! 95: switch(ch) ! 96: { ! 97: case ctrl('V'): ! 98: qaddch('^'); ! 99: qaddch('\b'); ! 100: quoted = TRUE; ! 101: break; ! 102: ! 103: case ctrl('['): ! 104: return -1; ! 105: ! 106: case '\n': ! 107: #if OSK ! 108: case '\l': ! 109: #else ! 110: case '\r': ! 111: #endif ! 112: clrtoeol(); ! 113: goto BreakBreak; ! 114: ! 115: case '\b': ! 116: if (len > 0) ! 117: { ! 118: len--; ! 119: #ifndef NO_DIGRAPH ! 120: erased = buf[len]; ! 121: #endif ! 122: for (ch = widths[len]; ch > 0; ch--) ! 123: addch('\b'); ! 124: if (mode == MODE_EX) ! 125: { ! 126: clrtoeol(); ! 127: } ! 128: tab -= widths[len]; ! 129: } ! 130: else ! 131: { ! 132: return -1; ! 133: } ! 134: break; ! 135: ! 136: default: ! 137: /* strip off quotation bit */ ! 138: if (ch & 256) ! 139: { ! 140: ch &= ~256; ! 141: qaddch(' '); ! 142: qaddch('\b'); ! 143: } ! 144: ! 145: /* add & echo the char */ ! 146: if (len < bsize - 1) ! 147: { ! 148: if (ch == '\t' && !quoted) ! 149: { ! 150: widths[len] = *o_tabstop - (tab % *o_tabstop); ! 151: addstr(" " + 8 - widths[len]); ! 152: tab += widths[len]; ! 153: } ! 154: else if (ch > 0 && ch < ' ') /* > 0 by GB */ ! 155: { ! 156: addch('^'); ! 157: addch(ch + '@'); ! 158: widths[len] = 2; ! 159: tab += 2; ! 160: } ! 161: else if (ch == '\177') ! 162: { ! 163: addch('^'); ! 164: addch('?'); ! 165: widths[len] = 2; ! 166: tab += 2; ! 167: } ! 168: else ! 169: { ! 170: addch(ch); ! 171: widths[len] = 1; ! 172: tab++; ! 173: } ! 174: buf[len++] = ch; ! 175: } ! 176: else ! 177: { ! 178: beep(); ! 179: } ! 180: quoted = FALSE; ! 181: } ! 182: } ! 183: BreakBreak: ! 184: refresh(); ! 185: buf[len] = '\0'; ! 186: return len; ! 187: } ! 188: ! 189: ! 190: static int manymsgs; /* This variable keeps msgs from overwriting each other */ ! 191: static char pmsg[80]; /* previous message (waiting to be displayed) */ ! 192: ! 193: ! 194: static int showmsg() ! 195: { ! 196: /* if there is no message to show, then don't */ ! 197: if (!manymsgs) ! 198: return FALSE; ! 199: ! 200: /* display the message */ ! 201: move(LINES - 1, 0); ! 202: if (*pmsg) ! 203: { ! 204: standout(); ! 205: qaddch(' '); ! 206: qaddstr(pmsg); ! 207: qaddch(' '); ! 208: standend(); ! 209: } ! 210: clrtoeol(); ! 211: ! 212: manymsgs = FALSE; ! 213: return TRUE; ! 214: } ! 215: ! 216: ! 217: void endmsgs() ! 218: { ! 219: if (manymsgs) ! 220: { ! 221: showmsg(); ! 222: addch('\n'); ! 223: } ! 224: } ! 225: ! 226: /* Write a message in an appropriate way. This should really be a varargs ! 227: * function, but there is no such thing as vwprintw. Hack!!! ! 228: * ! 229: * In MODE_EX or MODE_COLON, the message is written immediately, with a ! 230: * newline at the end. ! 231: * ! 232: * In MODE_VI, the message is stored in a character buffer. It is not ! 233: * displayed until getkey() is called. msg() will call getkey() itself, ! 234: * if necessary, to prevent messages from being lost. ! 235: * ! 236: * msg("") - clears the message line ! 237: * msg("%s %d", ...) - does a printf onto the message line ! 238: */ ! 239: #ifdef __STDC__ ! 240: void msg (char *fmt, ...) ! 241: { ! 242: va_list ap; ! 243: va_start (ap, fmt); ! 244: #else ! 245: void msg(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7) ! 246: char *fmt; ! 247: long arg1, arg2, arg3, arg4, arg5, arg6, arg7; ! 248: { ! 249: #endif ! 250: if (mode != MODE_VI) ! 251: { ! 252: #ifdef __STDC__ ! 253: vsprintf (pmsg, fmt, ap); ! 254: #else ! 255: sprintf(pmsg, fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7); ! 256: #endif ! 257: qaddstr(pmsg); ! 258: addch('\n'); ! 259: exrefresh(); ! 260: } ! 261: else ! 262: { ! 263: /* wait for keypress between consecutive msgs */ ! 264: if (manymsgs) ! 265: { ! 266: getkey(WHEN_MSG); ! 267: } ! 268: ! 269: /* real message */ ! 270: #ifdef __STDC__ ! 271: vsprintf (pmsg, fmt, ap); ! 272: #else ! 273: sprintf(pmsg, fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7); ! 274: #endif ! 275: if (*fmt) ! 276: { ! 277: manymsgs = TRUE; ! 278: } ! 279: } ! 280: #ifdef __STDC__ ! 281: va_end (ap); ! 282: #endif ! 283: } ! 284: ! 285: ! 286: /* This function calls refresh() if the option exrefresh is set */ ! 287: void exrefresh() ! 288: { ! 289: char *scan; ! 290: ! 291: /* If this ex command wrote ANYTHING set exwrote so vi's : command ! 292: * can tell that it must wait for a user keystroke before redrawing. ! 293: */ ! 294: for (scan=kbuf; scan<stdscr; scan++) ! 295: if (*scan == '\n') ! 296: exwrote = TRUE; ! 297: ! 298: /* now we do the refresh thing */ ! 299: if (*o_exrefresh) ! 300: { ! 301: refresh(); ! 302: } ! 303: else ! 304: { ! 305: wqrefresh(); ! 306: } ! 307: if (mode != MODE_VI) ! 308: { ! 309: manymsgs = FALSE; ! 310: } ! 311: } ! 312: ! 313: ! 314: /* This structure is used to store maps and abbreviations. The distinction ! 315: * between them is that maps are stored in the list referenced by the "maps" ! 316: * pointer, while abbreviations are referenced by the "abbrs" pointer. ! 317: */ ! 318: typedef struct _map ! 319: { ! 320: struct _map *next; /* another abbreviation */ ! 321: short len; /* length of the "rawin" characters */ ! 322: short flags; /* various flags */ ! 323: char *label; /* label of the map/abbr, or NULL */ ! 324: char *rawin; /* the "rawin" characters */ ! 325: char *cooked;/* the "cooked" characters */ ! 326: } MAP; ! 327: ! 328: static char keybuf[KEYBUFSIZE]; ! 329: static int cend; /* end of input characters */ ! 330: static int user; /* from user through end are chars typed by user */ ! 331: static int next; /* index of the next character to be returned */ ! 332: static MAP *match; /* the matching map, found by countmatch() */ ! 333: static MAP *maps; /* the map table */ ! 334: #ifndef NO_ABBR ! 335: static MAP *abbrs; /* the abbreviation table */ ! 336: #endif ! 337: ! 338: ! 339: ! 340: /* ring the terminal's bell */ ! 341: void beep() ! 342: { ! 343: /* do a visible/audible bell */ ! 344: if (*o_flash) ! 345: { ! 346: do_VB(); ! 347: refresh(); ! 348: } ! 349: else if (*o_errorbells) ! 350: { ! 351: tputs("\007", 1, faddch); ! 352: } ! 353: ! 354: /* discard any buffered input, and abort macros */ ! 355: next = user = cend; ! 356: } ! 357: ! 358: ! 359: ! 360: /* This function replaces a "rawin" character sequence with the "cooked" version, ! 361: * by modifying the internal type-ahead buffer. ! 362: */ ! 363: ! 364: void execmap(rawlen, cookedstr, visual) ! 365: int rawlen; /* length of rawin text -- string to delete */ ! 366: char *cookedstr; /* the cooked text -- string to insert */ ! 367: int visual; /* boolean -- chars to be executed in visual mode? */ ! 368: { ! 369: int cookedlen; ! 370: char *src, *dst; ! 371: int i; ! 372: ! 373: /* find the length of the cooked string */ ! 374: cookedlen = strlen(cookedstr); ! 375: #ifndef NO_EXTENSIONS ! 376: if (visual) ! 377: { ! 378: cookedlen *= 2; ! 379: } ! 380: #endif ! 381: ! 382: /* if too big to fit in type-ahead buffer, then don't do it */ ! 383: if (cookedlen + (cend - next) - rawlen > KEYBUFSIZE) ! 384: { ! 385: return; ! 386: } ! 387: ! 388: /* shift to make room for cookedstr at the front of keybuf */ ! 389: src = &keybuf[next + rawlen]; ! 390: dst = &keybuf[cookedlen]; ! 391: i = cend - (next + rawlen); ! 392: if (src >= dst) ! 393: { ! 394: while (i-- > 0) ! 395: { ! 396: *dst++ = *src++; ! 397: } ! 398: } ! 399: else ! 400: { ! 401: src += i; ! 402: dst += i; ! 403: while (i-- > 0) ! 404: { ! 405: *--dst = *--src; ! 406: } ! 407: } ! 408: ! 409: /* insert cookedstr, and adjust offsets */ ! 410: cend += cookedlen - rawlen - next; ! 411: user += cookedlen - rawlen - next; ! 412: next = 0; ! 413: for (dst = keybuf, src = cookedstr; *src; ) ! 414: { ! 415: #ifndef NO_EXTENSIONS ! 416: if (visual) ! 417: { ! 418: *dst++ = ctrl('O'); ! 419: cookedlen--; ! 420: } ! 421: #endif ! 422: *dst++ = *src++; ! 423: } ! 424: ! 425: #ifdef DEBUG2 ! 426: { ! 427: #include <stdio.h> ! 428: FILE *debout; ! 429: int i; ! 430: ! 431: debout = fopen("debug.out", "a"); ! 432: fprintf(debout, "After execmap(%d, \"%s\", %d)...\n", rawlen, cookedstr, visual); ! 433: for (i = 0; i < cend; i++) ! 434: { ! 435: if (i == next) fprintf(debout, "(next)"); ! 436: if (i == user) fprintf(debout, "(user)"); ! 437: if (UCHAR(keybuf[i]) < ' ') ! 438: fprintf(debout, "^%c", keybuf[i] ^ '@'); ! 439: else ! 440: fprintf(debout, "%c", keybuf[i]); ! 441: } ! 442: fprintf(debout, "(end)\n"); ! 443: fclose(debout); ! 444: } ! 445: #endif ! 446: } ! 447: ! 448: /* This function calls ttyread(). If necessary, it will also redraw the screen, ! 449: * change the cursor shape, display the mode, and update the ruler. If the ! 450: * number of characters read is 0, and we didn't time-out, then it exits because ! 451: * we've apparently reached the end of an EX script. ! 452: */ ! 453: static int fillkeybuf(when, timeout) ! 454: int when; /* mixture of WHEN_XXX flags */ ! 455: int timeout;/* timeout in 1/10 second increments, or 0 */ ! 456: { ! 457: int nkeys; ! 458: #ifndef NO_SHOWMODE ! 459: static int oldwhen; /* "when" from last time */ ! 460: static int oldleft; ! 461: static long oldtop; ! 462: static long oldnlines; ! 463: char *str; ! 464: #endif ! 465: #ifndef NO_CURSORSHAPE ! 466: static int oldcurs; ! 467: #endif ! 468: ! 469: #ifdef DEBUG ! 470: watch(); ! 471: #endif ! 472: ! 473: ! 474: #ifndef NO_CURSORSHAPE ! 475: /* make sure the cursor is the right shape */ ! 476: if (has_CQ) ! 477: { ! 478: if (when != oldcurs) ! 479: { ! 480: switch (when) ! 481: { ! 482: case WHEN_EX: do_CX(); break; ! 483: case WHEN_VICMD: do_CV(); break; ! 484: case WHEN_VIINP: do_CI(); break; ! 485: case WHEN_VIREP: do_CR(); break; ! 486: } ! 487: oldcurs = when; ! 488: } ! 489: } ! 490: #endif ! 491: ! 492: #ifndef NO_SHOWMODE ! 493: /* if "showmode" then say which mode we're in */ ! 494: if (*o_smd && (when & WHENMASK)) ! 495: { ! 496: /* redraw the screen before we check to see whether the ! 497: * "showmode" message needs to be redrawn. ! 498: */ ! 499: redraw(cursor, !(when & WHEN_VICMD)); ! 500: ! 501: /* now the "topline" test should be valid */ ! 502: if (when != oldwhen || topline != oldtop || leftcol != oldleft || nlines != oldnlines) ! 503: { ! 504: oldwhen = when; ! 505: oldtop = topline; ! 506: oldleft = leftcol; ! 507: oldnlines = nlines; ! 508: ! 509: if (when & WHEN_VICMD) str = "Command"; ! 510: else if (when & WHEN_VIINP) str = " Input "; ! 511: else if (when & WHEN_VIREP) str = "Replace"; ! 512: else if (when & WHEN_REP1) str = " Rep 1 "; ! 513: else if (when & WHEN_CUT) str = "BufName"; ! 514: else if (when & WHEN_MARK) str = "Mark AZ"; ! 515: else if (when & WHEN_CHAR) str = "Dest Ch"; ! 516: else str = (char *)0; ! 517: ! 518: if (str) ! 519: { ! 520: move(LINES - 1, COLS - 10); ! 521: standout(); ! 522: qaddstr(str); ! 523: standend(); ! 524: } ! 525: } ! 526: } ! 527: #endif ! 528: ! 529: #ifndef NO_EXTENSIONS ! 530: /* maybe display the ruler */ ! 531: if (*o_ruler && (when & (WHEN_VICMD|WHEN_VIINP|WHEN_VIREP))) ! 532: { ! 533: char buf[20]; ! 534: ! 535: redraw(cursor, !(when & WHEN_VICMD)); ! 536: pfetch(markline(cursor)); ! 537: sprintf(buf, "%7ld,%-4d", markline(cursor), 1 + idx2col(cursor, ptext, when & (WHEN_VIINP|WHEN_VIREP))); ! 538: move(LINES - 1, COLS - 22); ! 539: addstr(buf); ! 540: } ! 541: #endif ! 542: ! 543: /* redraw, so the cursor is in the right place */ ! 544: if (when & WHENMASK) ! 545: { ! 546: redraw(cursor, !(when & (WHENMASK & ~(WHEN_VIREP|WHEN_VIINP)))); ! 547: } ! 548: ! 549: /* Okay, now we can finally read the rawin keystrokes */ ! 550: refresh(); ! 551: nkeys = ttyread(keybuf + cend, sizeof keybuf - cend, timeout); ! 552: ! 553: /* if nkeys == 0 then we've reached EOF of an ex script. */ ! 554: if (nkeys == 0 && timeout == 0) ! 555: { ! 556: tmpabort(TRUE); ! 557: move(LINES - 1, 0); ! 558: clrtoeol(); ! 559: refresh(); ! 560: endwin(); ! 561: exit(exitcode); ! 562: } ! 563: ! 564: cend += nkeys; ! 565: user += nkeys; ! 566: return nkeys; ! 567: } ! 568: ! 569: ! 570: /* This function counts the number of maps that could match the characters ! 571: * between &keybuf[next] and &keybuf[cend], including incomplete matches. ! 572: * The longest comlete match is remembered via the "match" variable. ! 573: */ ! 574: static int countmatch(when) ! 575: int when; /* mixture of WHEN_XXX flags */ ! 576: { ! 577: MAP *map; ! 578: int count; ! 579: ! 580: /* clear the "match" variable */ ! 581: match = (MAP *)0; ! 582: ! 583: /* check every map */ ! 584: for (count = 0, map = maps; map; map = map->next) ! 585: { ! 586: /* can't match if wrong mode */ ! 587: if ((map->flags & when) == 0) ! 588: { ! 589: continue; ! 590: } ! 591: ! 592: /* would this be a complete match? */ ! 593: if (map->len <= cend - next) ! 594: { ! 595: /* Yes, it would be. Now does it really match? */ ! 596: if (!strncmp(map->rawin, &keybuf[next], map->len)) ! 597: { ! 598: count++; ! 599: ! 600: /* if this is the longest complete match, ! 601: * then remember it. ! 602: */ ! 603: if (!match || match->len < map->len) ! 604: { ! 605: match = map; ! 606: } ! 607: } ! 608: } ! 609: else ! 610: { ! 611: /* No, it wouldn't. But check for partial match */ ! 612: if (!strncmp(map->rawin, &keybuf[next], cend - next)) ! 613: { ! 614: count++; ! 615: } ! 616: } ! 617: } ! 618: return count; ! 619: } ! 620: ! 621: ! 622: #ifndef NO_ABBR ! 623: /* This function checks to see whether a word is an abbreviation. If it is, ! 624: * then an appropriate number of backspoace characters is inserted into the ! 625: * type-ahead buffer, followed by the expanded form of the abbreviation. ! 626: */ ! 627: static void expandabbr(word, wlen) ! 628: char *word; ! 629: int wlen; ! 630: { ! 631: MAP *abbr; ! 632: ! 633: /* if the next character wouldn't end the word, then don't expand */ ! 634: if (isalnum(keybuf[next]) || keybuf[next] == ctrl('V')) ! 635: { ! 636: return; ! 637: } ! 638: ! 639: /* find the abbreviation, if any */ ! 640: for (abbr = abbrs; ! 641: abbr && (abbr->len != wlen || strncmp(abbr->rawin, word, wlen)); ! 642: abbr = abbr->next) ! 643: { ! 644: } ! 645: ! 646: /* If an abbreviation was found, then expand it by inserting the long ! 647: * version into the type-ahead buffer, and then inserting (in front of ! 648: * the long version) enough backspaces to erase to the short version. ! 649: */ ! 650: if (abbr) ! 651: { ! 652: execmap(0, abbr->cooked, FALSE); ! 653: while (wlen > 15) ! 654: { ! 655: execmap(0, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b", FALSE); ! 656: wlen -= 15; ! 657: } ! 658: if (wlen > 0) ! 659: { ! 660: execmap(0, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" + 15 - wlen, FALSE); ! 661: } ! 662: } ! 663: } ! 664: #endif ! 665: ! 666: ! 667: /* This function calls getabkey() without attempting to expand abbreviations */ ! 668: int getkey(when) ! 669: int when; /* mixture of WHEN_XXX flags */ ! 670: { ! 671: return getabkey(when, "", 0); ! 672: } ! 673: ! 674: ! 675: /* This is it. This function returns keystrokes one-at-a-time, after mapping ! 676: * and abbreviations have been taken into account. ! 677: */ ! 678: int getabkey(when, word, wlen) ! 679: int when; /* mixture of WHEN_XXX flags */ ! 680: char *word; /* a word that may need to be expanded as an abbr */ ! 681: int wlen; /* length of "word" -- since "word" might not have \0 */ ! 682: { ! 683: int matches; ! 684: ! 685: /* if this key is needed for delay between multiple error messages, ! 686: * then reset the manymsgs flag and abort any mapped key sequence. ! 687: */ ! 688: if (showmsg()) ! 689: { ! 690: if (when == WHEN_MSG) ! 691: { ! 692: #ifndef CRUNCH ! 693: if (!*o_more) ! 694: { ! 695: refresh(); ! 696: return ' '; ! 697: } ! 698: #endif ! 699: qaddstr("[More...]"); ! 700: refresh(); ! 701: execmap(user, "", FALSE); ! 702: } ! 703: } ! 704: ! 705: #ifdef DEBUG ! 706: /* periodically check for screwed up internal tables */ ! 707: watch(); ! 708: #endif ! 709: ! 710: /* if buffer empty, read some characters without timeout */ ! 711: if (next >= cend) ! 712: { ! 713: next = user = cend = 0; ! 714: fillkeybuf(when, 0); ! 715: } ! 716: ! 717: /* try to map the key, unless already mapped and not ":set noremap" */ ! 718: if (next >= user || *o_remap) ! 719: { ! 720: do ! 721: { ! 722: do ! 723: { ! 724: matches = countmatch(when); ! 725: } while (matches > 1 && fillkeybuf(when, *o_keytime) > 0); ! 726: if (matches == 1) ! 727: { ! 728: if (match) { ! 729: execmap(match->len, match->cooked, ! 730: (match->flags & WHEN_INMV) != 0 ! 731: && (when & (WHEN_VIINP|WHEN_VIREP)) != 0); ! 732: } else ! 733: matches = 0; ! 734: } ! 735: } while (*o_remap && matches == 1); ! 736: } ! 737: ! 738: #ifndef NO_ABBR ! 739: /* try to expand an abbreviation, except in visual command mode */ ! 740: if (wlen > 0 && (mode & (WHEN_EX|WHEN_VIINP|WHEN_VIREP)) != 0) ! 741: { ! 742: expandabbr(word, wlen); ! 743: } ! 744: #endif ! 745: ! 746: /* ERASEKEY should always be mapped to '\b'. */ ! 747: if (keybuf[next] == ERASEKEY) ! 748: { ! 749: keybuf[next] = '\b'; ! 750: } ! 751: ! 752: /* return the next key */ ! 753: return keybuf[next++]; ! 754: } ! 755: ! 756: /* This function maps or unmaps a key */ ! 757: void mapkey(rawin, cooked, when, name) ! 758: char *rawin; /* the input key sequence, before mapping */ ! 759: char *cooked;/* after mapping -- or NULL to remove map */ ! 760: int when; /* bitmap of when mapping should happen */ ! 761: char *name; /* name of the key, NULL for no name, "abbr" for abbr */ ! 762: { ! 763: MAP **head; /* head of list of maps or abbreviations */ ! 764: MAP *scan; /* used for scanning through the list */ ! 765: MAP *prev; /* used during deletions */ ! 766: ! 767: /* Is this a map or an abbreviation? Choose the right list. */ ! 768: #ifndef NO_ABBR ! 769: head = ((!name || strcmp(name, "abbr")) ? &maps : &abbrs); ! 770: #else ! 771: head = &maps; ! 772: #endif ! 773: ! 774: /* try to find the map in the list */ ! 775: for (scan = *head, prev = (MAP *)0; ! 776: scan && (strcmp(rawin, scan->rawin) || ! 777: !(scan->flags & when & (WHEN_EX|WHEN_VICMD|WHEN_VIINP|WHEN_VIREP))); ! 778: prev = scan, scan = scan->next) ! 779: { ! 780: } ! 781: ! 782: /* trying to map? (not unmap) */ ! 783: if (cooked && *cooked) ! 784: { ! 785: /* if map starts with "visual ", then mark it as a visual map */ ! 786: if (head == &maps && !strncmp(cooked, "visual ", 7)) ! 787: { ! 788: cooked += 7; ! 789: when |= WHEN_INMV; ! 790: } ! 791: ! 792: /* "visual" maps always work in input mode */ ! 793: if (when & WHEN_INMV) ! 794: { ! 795: when |= WHEN_VIINP|WHEN_VIREP|WHEN_POPUP; ! 796: } ! 797: ! 798: /* if not already in the list, then allocate a new structure */ ! 799: if (!scan) ! 800: { ! 801: scan = (MAP *)malloc(sizeof(MAP)); ! 802: scan->len = strlen(rawin); ! 803: scan->rawin = malloc((unsigned)(scan->len + 1)); ! 804: strcpy(scan->rawin, rawin); ! 805: scan->flags = when; ! 806: scan->label = name; ! 807: if (*head) ! 808: { ! 809: prev->next = scan; ! 810: } ! 811: else ! 812: { ! 813: *head = scan; ! 814: } ! 815: scan->next = (MAP *)0; ! 816: } ! 817: else /* recycle old structure */ ! 818: { ! 819: _free_(scan->cooked); ! 820: } ! 821: scan->cooked = malloc((unsigned)(strlen(cooked) + 1)); ! 822: strcpy(scan->cooked, cooked); ! 823: } ! 824: else /* unmapping */ ! 825: { ! 826: /* if nothing to unmap, then exit silently */ ! 827: if (!scan) ! 828: { ! 829: return; ! 830: } ! 831: ! 832: /* unlink the structure from the list */ ! 833: if (prev) ! 834: { ! 835: prev->next = scan->next; ! 836: } ! 837: else ! 838: { ! 839: *head = scan->next; ! 840: } ! 841: ! 842: /* free it, and the strings that it refers to */ ! 843: _free_(scan->rawin); ! 844: _free_(scan->cooked); ! 845: _free_(scan); ! 846: } ! 847: } ! 848: ! 849: ! 850: /* This function returns a printable version of a string. It uses tmpblk.c */ ! 851: char *printable(str) ! 852: char *str; /* the string to convert */ ! 853: { ! 854: char *build; /* used for building the string */ ! 855: ! 856: for (build = tmpblk.c; *str; str++) ! 857: { ! 858: #if AMIGA ! 859: if (*str == '\233') ! 860: { ! 861: *build++ = '<'; ! 862: *build++ = 'C'; ! 863: *build++ = 'S'; ! 864: *build++ = 'I'; ! 865: *build++ = '>'; ! 866: } else ! 867: #endif ! 868: if (UCHAR(*str) < ' ' || *str == '\177') ! 869: { ! 870: *build++ = '^'; ! 871: *build++ = *str ^ '@'; ! 872: } ! 873: else ! 874: { ! 875: *build++ = *str; ! 876: } ! 877: } ! 878: *build = '\0'; ! 879: return tmpblk.c; ! 880: } ! 881: ! 882: /* This function displays the contents of either the map table or the ! 883: * abbreviation table. User commands call this function as follows: ! 884: * :map dumpkey(WHEN_VICMD, FALSE); ! 885: * :map! dumpkey(WHEN_VIREP|WHEN_VIINP, FALSE); ! 886: * :abbr dumpkey(WHEN_VIINP|WHEN_VIREP, TRUE); ! 887: * :abbr! dumpkey(WHEN_EX|WHEN_VIINP|WHEN_VIREP, TRUE); ! 888: */ ! 889: void dumpkey(when, abbr) ! 890: int when; /* WHEN_XXXX of mappings to be dumped */ ! 891: int abbr; /* boolean: dump abbreviations instead of maps? */ ! 892: { ! 893: MAP *scan; ! 894: char *str; ! 895: int len; ! 896: ! 897: #ifndef NO_ABBR ! 898: for (scan = (abbr ? abbrs : maps); scan; scan = scan->next) ! 899: #else ! 900: for (scan = maps; scan; scan = scan->next) ! 901: #endif ! 902: { ! 903: /* skip entries that don't match "when" */ ! 904: if ((scan->flags & when) == 0) ! 905: { ! 906: continue; ! 907: } ! 908: ! 909: /* dump the key label, if any */ ! 910: if (!abbr) ! 911: { ! 912: len = 8; ! 913: if (scan->label) ! 914: { ! 915: qaddstr(scan->label); ! 916: len -= strlen(scan->label); ! 917: } ! 918: do ! 919: { ! 920: qaddch(' '); ! 921: } while (len-- > 0); ! 922: } ! 923: ! 924: /* dump the rawin version */ ! 925: str = printable(scan->rawin); ! 926: qaddstr(str); ! 927: len = strlen(str); ! 928: do ! 929: { ! 930: qaddch(' '); ! 931: } while (len++ < 8); ! 932: ! 933: /* dump the mapped version */ ! 934: #ifndef NO_EXTENSIONS ! 935: if ((scan->flags & WHEN_INMV) && (when & (WHEN_VIINP|WHEN_VIREP))) ! 936: { ! 937: qaddstr("visual "); ! 938: } ! 939: #endif ! 940: str = printable(scan->cooked); ! 941: qaddstr(str); ! 942: addch('\n'); ! 943: exrefresh(); ! 944: } ! 945: } ! 946: ! 947: #ifndef NO_MKEXRC ! 948: ! 949: static void safequote(str) ! 950: char *str; ! 951: { ! 952: char *build; ! 953: ! 954: build = tmpblk.c + strlen(tmpblk.c); ! 955: while (*str) ! 956: { ! 957: if (*str <= ' ' && *str >= 1 || *str == '|') ! 958: { ! 959: *build++ = ctrl('V'); ! 960: } ! 961: *build++ = *str++; ! 962: } ! 963: *build = '\0'; ! 964: } ! 965: ! 966: /* This function saves the contents of either the map table or the ! 967: * abbreviation table into a file. Both the "bang" and "no bang" versions ! 968: * are saved. ! 969: * :map dumpkey(WHEN_VICMD, FALSE); ! 970: * :map! dumpkey(WHEN_VIREP|WHEN_VIINP, FALSE); ! 971: * :abbr dumpkey(WHEN_VIINP|WHEN_VIREP, TRUE); ! 972: * :abbr! dumpkey(WHEN_EX|WHEN_VIINP|WHEN_VIREP, TRUE); ! 973: */ ! 974: void ! 975: savemaps(fd, abbr) ! 976: int fd; /* file descriptor of an open file to write to */ ! 977: int abbr; /* boolean: do abbr table? (else do map table) */ ! 978: { ! 979: MAP *scan; ! 980: int bang; ! 981: int when; ! 982: ! 983: # ifndef NO_ABBR ! 984: for (scan = (abbr ? abbrs : maps); scan; scan = scan->next) ! 985: # else ! 986: for (scan = maps; scan; scan = scan->next) ! 987: # endif ! 988: { ! 989: /* skip maps that have labels, except for function keys */ ! 990: if (scan->label && *scan->label != '#') ! 991: { ! 992: continue; ! 993: } ! 994: ! 995: for (bang = 0; bang < 2; bang++) ! 996: { ! 997: /* decide which "when" flags we want */ ! 998: # ifndef NO_ABBR ! 999: if (abbr) ! 1000: when = (bang ? WHEN_EX|WHEN_VIINP|WHEN_VIREP : WHEN_VIINP|WHEN_VIREP); ! 1001: else ! 1002: # endif ! 1003: when = (bang ? WHEN_VIREP|WHEN_VIINP : WHEN_VICMD); ! 1004: ! 1005: /* skip entries that don't match "when" */ ! 1006: if ((scan->flags & when) == 0) ! 1007: { ! 1008: continue; ! 1009: } ! 1010: ! 1011: /* write a "map" or "abbr" command name */ ! 1012: # ifndef NO_ABBR ! 1013: if (abbr) ! 1014: strcpy(tmpblk.c, "abbr"); ! 1015: else ! 1016: # endif ! 1017: strcpy(tmpblk.c, "map"); ! 1018: ! 1019: /* maybe write a bang. Definitely write a space */ ! 1020: if (bang) ! 1021: strcat(tmpblk.c, "! "); ! 1022: else ! 1023: strcat(tmpblk.c, " "); ! 1024: ! 1025: /* write the rawin version */ ! 1026: # ifndef NO_FKEY ! 1027: if (scan->label) ! 1028: strcat(tmpblk.c, scan->label); ! 1029: else ! 1030: # endif ! 1031: safequote(scan->rawin); ! 1032: strcat(tmpblk.c, " "); ! 1033: ! 1034: /* dump the mapped version */ ! 1035: # ifndef NO_EXTENSIONS ! 1036: if ((scan->flags & WHEN_INMV) && (when & (WHEN_VIINP|WHEN_VIREP))) ! 1037: { ! 1038: strcat(tmpblk.c, "visual "); ! 1039: } ! 1040: # endif ! 1041: safequote(scan->cooked); ! 1042: strcat(tmpblk.c, "\n"); ! 1043: twrite(fd, tmpblk.c, strlen(tmpblk.c)); ! 1044: } ! 1045: } ! 1046: } ! 1047: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.