![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / ex|
Return to ex_vops.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / ex |
1.1 ! root 1: /* Copyright (c) 1980 Regents of the University of California */ ! 2: static char *sccsid = "@(#)ex_vops.c 6.3 10/23/80"; ! 3: #include "ex.h" ! 4: #include "ex_tty.h" ! 5: #include "ex_vis.h" ! 6: ! 7: /* ! 8: * This file defines the operation sequences which interface the ! 9: * logical changes to the file buffer with the internal and external ! 10: * display representations. ! 11: */ ! 12: ! 13: /* ! 14: * Undo. ! 15: * ! 16: * Undo is accomplished in two ways. We often for small changes in the ! 17: * current line know how (in terms of a change operator) how the change ! 18: * occurred. Thus on an intelligent terminal we can undo the operation ! 19: * by another such operation, using insert and delete character ! 20: * stuff. The pointers vU[AD][12] index the buffer vutmp when this ! 21: * is possible and provide the necessary information. ! 22: * ! 23: * The other case is that the change involved multiple lines or that ! 24: * we have moved away from the line or forgotten how the change was ! 25: * accomplished. In this case we do a redisplay and hope that the ! 26: * low level optimization routines (which don't look for winning ! 27: * via insert/delete character) will not lose too badly. ! 28: */ ! 29: char *vUA1, *vUA2; ! 30: char *vUD1, *vUD2; ! 31: ! 32: vUndo() ! 33: { ! 34: ! 35: /* ! 36: * Avoid UU which clobbers ability to do u. ! 37: */ ! 38: if (vundkind == VCAPU || vUNDdot != dot) { ! 39: beep(); ! 40: return; ! 41: } ! 42: CP(vutmp, linebuf); ! 43: vUD1 = linebuf; vUD2 = strend(linebuf); ! 44: putmk1(dot, vUNDsav); ! 45: getDOT(); ! 46: vUA1 = linebuf; vUA2 = strend(linebuf); ! 47: vundkind = VCAPU; ! 48: if (state == ONEOPEN || state == HARDOPEN) { ! 49: vjumpto(dot, vUNDcurs, 0); ! 50: return; ! 51: } ! 52: vdirty(vcline, 1); ! 53: vsyncCL(); ! 54: cursor = linebuf; ! 55: vfixcurs(); ! 56: } ! 57: ! 58: vundo(show) ! 59: bool show; /* if true update the screen */ ! 60: { ! 61: register int cnt; ! 62: register line *addr; ! 63: register char *cp; ! 64: char temp[LBSIZE]; ! 65: bool savenote; ! 66: int (*OO)(); ! 67: short oldhold = hold; ! 68: ! 69: switch (vundkind) { ! 70: ! 71: case VMANYINS: ! 72: wcursor = 0; ! 73: addr1 = undap1; ! 74: addr2 = undap2 - 1; ! 75: vsave(); ! 76: YANKreg('1'); ! 77: notecnt = 0; ! 78: /* fall into ... */ ! 79: ! 80: case VMANY: ! 81: case VMCHNG: ! 82: vsave(); ! 83: addr = dot - vcline; ! 84: notecnt = 1; ! 85: if (undkind == UNDPUT && undap1 == undap2) { ! 86: beep(); ! 87: break; ! 88: } ! 89: /* ! 90: * Undo() call below basically replaces undap1 to undap2-1 ! 91: * with dol through unddol-1. Hack screen image to ! 92: * reflect this replacement. ! 93: */ ! 94: if (show) ! 95: if (undkind == UNDMOVE) ! 96: vdirty(0, LINES); ! 97: else ! 98: vreplace(undap1 - addr, undap2 - undap1, ! 99: undkind == UNDPUT ? 0 : unddol - dol); ! 100: savenote = notecnt; ! 101: undo(1); ! 102: if (show && (vundkind != VMCHNG || addr != dot)) ! 103: killU(); ! 104: vundkind = VMANY; ! 105: cnt = dot - addr; ! 106: if (cnt < 0 || cnt > vcnt || state != VISUAL) { ! 107: if (show) ! 108: vjumpto(dot, NOSTR, '.'); ! 109: break; ! 110: } ! 111: if (!savenote) ! 112: notecnt = 0; ! 113: if (show) { ! 114: vcline = cnt; ! 115: vrepaint(vmcurs); ! 116: } ! 117: vmcurs = 0; ! 118: break; ! 119: ! 120: case VCHNG: ! 121: case VCAPU: ! 122: vundkind = VCHNG; ! 123: strcpy(temp, vutmp); ! 124: strcpy(vutmp, linebuf); ! 125: doomed = column(vUA2 - 1) - column(vUA1 - 1); ! 126: strcLIN(temp); ! 127: cp = vUA1; vUA1 = vUD1; vUD1 = cp; ! 128: cp = vUA2; vUA2 = vUD2; vUD2 = cp; ! 129: if (!show) ! 130: break; ! 131: cursor = vUD1; ! 132: if (state == HARDOPEN) { ! 133: doomed = 0; ! 134: vsave(); ! 135: vopen(dot, WBOT); ! 136: vnline(cursor); ! 137: break; ! 138: } ! 139: /* ! 140: * Pseudo insert command. ! 141: */ ! 142: vcursat(cursor); ! 143: OO = Outchar; Outchar = vinschar; hold |= HOLDQIK; ! 144: vprepins(); ! 145: temp[vUA2 - linebuf] = 0; ! 146: for (cp = &temp[vUA1 - linebuf]; *cp;) ! 147: putchar(*cp++); ! 148: Outchar = OO; hold = oldhold; ! 149: endim(); ! 150: physdc(cindent(), cindent() + doomed); ! 151: doomed = 0; ! 152: vdirty(vcline, 1); ! 153: vsyncCL(); ! 154: if (cursor > linebuf && cursor >= strend(linebuf)) ! 155: cursor--; ! 156: vfixcurs(); ! 157: break; ! 158: ! 159: case VNONE: ! 160: beep(); ! 161: break; ! 162: } ! 163: } ! 164: ! 165: /* ! 166: * Routine to handle a change inside a macro. ! 167: * Fromvis is true if we were called from a visual command (as ! 168: * opposed to an ex command). This has nothing to do with being ! 169: * in open/visual mode as :s/foo/bar is not fromvis. ! 170: */ ! 171: vmacchng(fromvis) ! 172: bool fromvis; ! 173: { ! 174: line *savedot, *savedol; ! 175: char *savecursor; ! 176: char savelb[LBSIZE]; ! 177: int nlines, more; ! 178: register line *a1, *a2; ! 179: char ch; /* DEBUG */ ! 180: int copyw(), copywR(); ! 181: ! 182: if (!inopen) ! 183: return; ! 184: if (!vmacp) ! 185: vch_mac = VC_NOTINMAC; ! 186: #ifdef TRACE ! 187: if (trace) ! 188: fprintf(trace, "vmacchng, vch_mac=%d, linebuf='%s', *dot=%o\n", vch_mac, linebuf, *dot); ! 189: #endif ! 190: if (vmacp && fromvis) ! 191: vsave(); ! 192: #ifdef TRACE ! 193: if (trace) ! 194: fprintf(trace, "after vsave, linebuf='%s', *dot=%o\n", linebuf, *dot); ! 195: #endif ! 196: switch(vch_mac) { ! 197: case VC_NOCHANGE: ! 198: vch_mac = VC_ONECHANGE; ! 199: break; ! 200: case VC_ONECHANGE: ! 201: /* Save current state somewhere */ ! 202: #ifdef TRACE ! 203: vudump("before vmacchng hairy case"); ! 204: #endif ! 205: savedot = dot; savedol = dol; savecursor = cursor; ! 206: CP(savelb, linebuf); ! 207: nlines = dol - zero; ! 208: while ((line *) endcore - truedol < nlines) ! 209: morelines(); ! 210: copyw(truedol+1, zero+1, nlines); ! 211: truedol += nlines; ! 212: ! 213: #ifdef TRACE ! 214: visdump("before vundo"); ! 215: #endif ! 216: /* Restore state as it was at beginning of macro */ ! 217: vundo(0); ! 218: #ifdef TRACE ! 219: visdump("after vundo"); ! 220: vudump("after vundo"); ! 221: #endif ! 222: ! 223: /* Do the saveall we should have done then */ ! 224: saveall(); ! 225: #ifdef TRACE ! 226: vudump("after saveall"); ! 227: #endif ! 228: ! 229: /* Restore current state from where saved */ ! 230: more = savedol - dol; /* amount we shift everything by */ ! 231: if (more) ! 232: (*(more>0 ? copywR : copyw))(savedol+1, dol+1, truedol-dol); ! 233: unddol += more; truedol += more; undap2 += more; ! 234: ! 235: truedol -= nlines; ! 236: copyw(zero+1, truedol+1, nlines); ! 237: dot = savedot; dol = savedol ; cursor = savecursor; ! 238: CP(linebuf, savelb); ! 239: vch_mac = VC_MANYCHANGE; ! 240: ! 241: /* Arrange that no further undo saving happens within macro */ ! 242: otchng = tchng; /* Copied this line blindly - bug? */ ! 243: inopen = -1; /* no need to save since it had to be 1 or -1 before */ ! 244: vundkind = VMANY; ! 245: #ifdef TRACE ! 246: vudump("after vmacchng"); ! 247: #endif ! 248: break; ! 249: case VC_NOTINMAC: ! 250: case VC_MANYCHANGE: ! 251: /* Nothing to do for various reasons. */ ! 252: break; ! 253: } ! 254: } ! 255: ! 256: /* ! 257: * Initialize undo information before an append. ! 258: */ ! 259: vnoapp() ! 260: { ! 261: ! 262: vUD1 = vUD2 = cursor; ! 263: } ! 264: ! 265: /* ! 266: * All the rest of the motion sequences have one or more ! 267: * cases to deal with. In the case wdot == 0, operation ! 268: * is totally within current line, from cursor to wcursor. ! 269: * If wdot is given, but wcursor is 0, then operation affects ! 270: * the inclusive line range. The hardest case is when both wdot ! 271: * and wcursor are given, then operation affects from line dot at ! 272: * cursor to line wdot at wcursor. ! 273: */ ! 274: ! 275: /* ! 276: * Move is simple, except for moving onto new lines in hardcopy open mode. ! 277: */ ! 278: vmove() ! 279: { ! 280: register int cnt; ! 281: ! 282: if (wdot) { ! 283: if (wdot < one || wdot > dol) { ! 284: beep(); ! 285: return; ! 286: } ! 287: cnt = wdot - dot; ! 288: wdot = NOLINE; ! 289: if (cnt) ! 290: killU(); ! 291: vupdown(cnt, wcursor); ! 292: return; ! 293: } ! 294: ! 295: /* ! 296: * When we move onto a new line, save information for U undo. ! 297: */ ! 298: if (vUNDdot != dot) { ! 299: vUNDsav = *dot; ! 300: vUNDcurs = wcursor; ! 301: vUNDdot = dot; ! 302: } ! 303: ! 304: /* ! 305: * In hardcopy open, type characters to left of cursor ! 306: * on new line, or back cursor up if its to left of where we are. ! 307: * In any case if the current line is ``rubbled'' i.e. has trashy ! 308: * looking overstrikes on it or \'s from deletes, we reprint ! 309: * so it is more comprehensible (and also because we can't work ! 310: * if we let it get more out of sync since column() won't work right. ! 311: */ ! 312: if (state == HARDOPEN) { ! 313: register char *cp; ! 314: if (rubble) { ! 315: register int c; ! 316: int oldhold = hold; ! 317: ! 318: sethard(); ! 319: cp = wcursor; ! 320: c = *cp; ! 321: *cp = 0; ! 322: hold |= HOLDDOL; ! 323: vreopen(WTOP, lineDOT(), vcline); ! 324: hold = oldhold; ! 325: *cp = c; ! 326: } else if (wcursor > cursor) { ! 327: vfixcurs(); ! 328: for (cp = cursor; *cp && cp < wcursor;) { ! 329: register int c = *cp++ & TRIM; ! 330: ! 331: putchar(c ? c : ' '); ! 332: } ! 333: } ! 334: } ! 335: vsetcurs(wcursor); ! 336: } ! 337: ! 338: /* ! 339: * Delete operator. ! 340: * ! 341: * Hard case of deleting a range where both wcursor and wdot ! 342: * are specified is treated as a special case of change and handled ! 343: * by vchange (although vchange may pass it back if it degenerates ! 344: * to a full line range delete.) ! 345: */ ! 346: vdelete(c) ! 347: char c; ! 348: { ! 349: register char *cp; ! 350: register int i; ! 351: ! 352: if (wdot) { ! 353: if (wcursor) { ! 354: vchange('d'); ! 355: return; ! 356: } ! 357: if ((i = xdw()) < 0) ! 358: return; ! 359: if (state != VISUAL) { ! 360: vgoto(LINE(0), 0); ! 361: vputchar('@'); ! 362: } ! 363: wdot = dot; ! 364: vremote(i, delete, 0); ! 365: notenam = "delete"; ! 366: DEL[0] = 0; ! 367: killU(); ! 368: vreplace(vcline, i, 0); ! 369: if (wdot > dol) ! 370: vcline--; ! 371: vrepaint(NOSTR); ! 372: return; ! 373: } ! 374: if (wcursor < linebuf) ! 375: wcursor = linebuf; ! 376: if (cursor == wcursor) { ! 377: beep(); ! 378: return; ! 379: } ! 380: i = vdcMID(); ! 381: cp = cursor; ! 382: setDEL(); ! 383: CP(cp, wcursor); ! 384: if (cp > linebuf && (cp[0] == 0 || c == '#')) ! 385: cp--; ! 386: if (state == HARDOPEN) { ! 387: bleep(i, cp); ! 388: cursor = cp; ! 389: return; ! 390: } ! 391: physdc(column(cursor - 1), i); ! 392: DEPTH(vcline) = 0; ! 393: vreopen(LINE(vcline), lineDOT(), vcline); ! 394: vsyncCL(); ! 395: vsetcurs(cp); ! 396: } ! 397: ! 398: /* ! 399: * Change operator. ! 400: * ! 401: * In a single line we mark the end of the changed area with '$'. ! 402: * On multiple whole lines, we clear the lines first. ! 403: * Across lines with both wcursor and wdot given, we delete ! 404: * and sync then append (but one operation for undo). ! 405: */ ! 406: vchange(c) ! 407: char c; ! 408: { ! 409: register char *cp; ! 410: register int i, ind, cnt; ! 411: line *addr; ! 412: ! 413: if (wdot) { ! 414: /* ! 415: * Change/delete of lines or across line boundaries. ! 416: */ ! 417: if ((cnt = xdw()) < 0) ! 418: return; ! 419: getDOT(); ! 420: if (wcursor && cnt == 1) { ! 421: /* ! 422: * Not really. ! 423: */ ! 424: wdot = 0; ! 425: if (c == 'd') { ! 426: vdelete(c); ! 427: return; ! 428: } ! 429: goto smallchange; ! 430: } ! 431: if (cursor && wcursor) { ! 432: /* ! 433: * Across line boundaries, but not ! 434: * necessarily whole lines. ! 435: * Construct what will be left. ! 436: */ ! 437: *cursor = 0; ! 438: strcpy(genbuf, linebuf); ! 439: getline(*wdot); ! 440: if (strlen(genbuf) + strlen(wcursor) > LBSIZE - 2) { ! 441: getDOT(); ! 442: beep(); ! 443: return; ! 444: } ! 445: strcat(genbuf, wcursor); ! 446: if (c == 'd' && *vpastwh(genbuf) == 0) { ! 447: /* ! 448: * Although this is a delete ! 449: * spanning line boundaries, what ! 450: * would be left is all white space, ! 451: * so take it all away. ! 452: */ ! 453: wcursor = 0; ! 454: getDOT(); ! 455: op = 0; ! 456: notpart(lastreg); ! 457: notpart('1'); ! 458: vdelete(c); ! 459: return; ! 460: } ! 461: ind = -1; ! 462: } else if (c == 'd' && wcursor == 0) { ! 463: vdelete(c); ! 464: return; ! 465: } else ! 466: #ifdef LISPCODE ! 467: /* ! 468: * We are just substituting text for whole lines, ! 469: * so determine the first autoindent. ! 470: */ ! 471: if (value(LISP) && value(AUTOINDENT)) ! 472: ind = lindent(dot); ! 473: else ! 474: #endif ! 475: ind = whitecnt(linebuf); ! 476: i = vcline >= 0 ? LINE(vcline) : WTOP; ! 477: ! 478: /* ! 479: * Delete the lines from the buffer, ! 480: * and remember how the partial stuff came about in ! 481: * case we are told to put. ! 482: */ ! 483: addr = dot; ! 484: vremote(cnt, delete, 0); ! 485: setpk(); ! 486: notenam = "delete"; ! 487: if (c != 'd') ! 488: notenam = "change"; ! 489: /* ! 490: * If DEL[0] were nonzero, put would put it back ! 491: * rather than the deleted lines. ! 492: */ ! 493: DEL[0] = 0; ! 494: if (cnt > 1) ! 495: killU(); ! 496: ! 497: /* ! 498: * Now hack the screen image coordination. ! 499: */ ! 500: vreplace(vcline, cnt, 0); ! 501: wdot = NOLINE; ! 502: noteit(0); ! 503: vcline--; ! 504: if (addr <= dol) ! 505: dot--; ! 506: ! 507: /* ! 508: * If this is a across line delete/change, ! 509: * cursor stays where it is; just splice together the pieces ! 510: * of the new line. Otherwise generate a autoindent ! 511: * after a S command. ! 512: */ ! 513: if (ind >= 0) { ! 514: *genindent(ind) = 0; ! 515: vdoappend(genbuf); ! 516: } else { ! 517: vmcurs = cursor; ! 518: strcLIN(genbuf); ! 519: vdoappend(linebuf); ! 520: } ! 521: ! 522: /* ! 523: * Indicate a change on hardcopies by ! 524: * erasing the current line. ! 525: */ ! 526: if (c != 'd' && state != VISUAL && state != HARDOPEN) { ! 527: int oldhold = hold; ! 528: ! 529: hold |= HOLDAT, vclrlin(i, dot), hold = oldhold; ! 530: } ! 531: ! 532: /* ! 533: * Open the line (logically) on the screen, and ! 534: * update the screen tail. Unless we are really a delete ! 535: * go off and gather up inserted characters. ! 536: */ ! 537: vcline++; ! 538: if (vcline < 0) ! 539: vcline = 0; ! 540: vopen(dot, i); ! 541: vsyncCL(); ! 542: noteit(1); ! 543: if (c != 'd') { ! 544: if (ind >= 0) { ! 545: cursor = linebuf; ! 546: linebuf[0] = 0; ! 547: vfixcurs(); ! 548: } else { ! 549: ind = 0; ! 550: vcursat(cursor); ! 551: } ! 552: vappend('x', 1, ind); ! 553: return; ! 554: } ! 555: if (*cursor == 0 && cursor > linebuf) ! 556: cursor--; ! 557: vrepaint(cursor); ! 558: return; ! 559: } ! 560: ! 561: smallchange: ! 562: /* ! 563: * The rest of this is just low level hacking on changes ! 564: * of small numbers of characters. ! 565: */ ! 566: if (wcursor < linebuf) ! 567: wcursor = linebuf; ! 568: if (cursor == wcursor) { ! 569: beep(); ! 570: return; ! 571: } ! 572: i = vdcMID(); ! 573: cp = cursor; ! 574: if (state != HARDOPEN) ! 575: vfixcurs(); ! 576: ! 577: /* ! 578: * Put out the \\'s indicating changed text in hardcopy, ! 579: * or mark the end of the change with $ if not hardcopy. ! 580: */ ! 581: if (state == HARDOPEN) ! 582: bleep(i, cp); ! 583: else { ! 584: vcursbef(wcursor); ! 585: putchar('$'); ! 586: i = cindent(); ! 587: } ! 588: ! 589: /* ! 590: * Remember the deleted text for possible put, ! 591: * and then prepare and execute the input portion of the change. ! 592: */ ! 593: cursor = cp; ! 594: setDEL(); ! 595: CP(cursor, wcursor); ! 596: if (state != HARDOPEN) { ! 597: vcursaft(cursor - 1); ! 598: doomed = i - cindent(); ! 599: } else { ! 600: /* ! 601: sethard(); ! 602: wcursor = cursor; ! 603: cursor = linebuf; ! 604: vgoto(outline, value(NUMBER) << 3); ! 605: vmove(); ! 606: */ ! 607: doomed = 0; ! 608: } ! 609: prepapp(); ! 610: vappend('c', 1, 0); ! 611: } ! 612: ! 613: /* ! 614: * Open new lines. ! 615: * ! 616: * Tricky thing here is slowopen. This causes display updating ! 617: * to be held off so that 300 baud dumb terminals don't lose badly. ! 618: * This also suppressed counts, which otherwise say how many blank ! 619: * space to open up. Counts are also suppressed on intelligent terminals. ! 620: * Actually counts are obsoleted, since if your terminal is slow ! 621: * you are better off with slowopen. ! 622: */ ! 623: voOpen(c, cnt) ! 624: char c; ! 625: register int cnt; ! 626: { ! 627: register int ind = 0, i; ! 628: short oldhold = hold; ! 629: ! 630: if (value(SLOWOPEN) || value(REDRAW) && AL && DL) ! 631: cnt = 1; ! 632: vsave(); ! 633: setLAST(); ! 634: if (value(AUTOINDENT)) ! 635: ind = whitecnt(linebuf); ! 636: if (c == 'O') { ! 637: vcline--; ! 638: dot--; ! 639: if (dot > zero) ! 640: getDOT(); ! 641: } ! 642: if (value(AUTOINDENT)) { ! 643: #ifdef LISPCODE ! 644: if (value(LISP)) ! 645: ind = lindent(dot + 1); ! 646: #endif ! 647: } ! 648: killU(); ! 649: prepapp(); ! 650: if (FIXUNDO) ! 651: vundkind = VMANY; ! 652: if (state != VISUAL) ! 653: c = WBOT + 1; ! 654: else { ! 655: c = vcline < 0 ? WTOP - cnt : LINE(vcline) + DEPTH(vcline); ! 656: if (c < ZERO) ! 657: c = ZERO; ! 658: i = LINE(vcline + 1) - c; ! 659: if (i < cnt && c <= WBOT && (!AL || !DL)) ! 660: vinslin(c, cnt - i, vcline); ! 661: } ! 662: *genindent(ind) = 0; ! 663: vdoappend(genbuf); ! 664: vcline++; ! 665: oldhold = hold; ! 666: hold |= HOLDROL; ! 667: vopen(dot, c); ! 668: hold = oldhold; ! 669: if (value(SLOWOPEN)) ! 670: /* ! 671: * Oh, so lazy! ! 672: */ ! 673: vscrap(); ! 674: else ! 675: vsync1(LINE(vcline)); ! 676: cursor = linebuf; ! 677: linebuf[0] = 0; ! 678: vappend('o', 1, ind); ! 679: } ! 680: ! 681: /* ! 682: * > < and = shift operators. ! 683: * ! 684: * Note that =, which aligns lisp, is just a ragged sort of shift, ! 685: * since it never distributes text between lines. ! 686: */ ! 687: char vshnam[2] = { 'x', 0 }; ! 688: ! 689: vshftop() ! 690: { ! 691: register line *addr; ! 692: register int cnt; ! 693: ! 694: if ((cnt = xdw()) < 0) ! 695: return; ! 696: addr = dot; ! 697: vremote(cnt, vshift, 0); ! 698: vshnam[0] = op; ! 699: notenam = vshnam; ! 700: dot = addr; ! 701: vreplace(vcline, cnt, cnt); ! 702: if (state == HARDOPEN) ! 703: vcnt = 0; ! 704: vrepaint(NOSTR); ! 705: } ! 706: ! 707: /* ! 708: * !. ! 709: * ! 710: * Filter portions of the buffer through unix commands. ! 711: */ ! 712: vfilter() ! 713: { ! 714: register line *addr; ! 715: register int cnt; ! 716: char *oglobp, d; ! 717: ! 718: if ((cnt = xdw()) < 0) ! 719: return; ! 720: if (vglobp) ! 721: vglobp = uxb; ! 722: if (readecho('!')) ! 723: return; ! 724: oglobp = globp; globp = genbuf + 1; ! 725: d = peekc; ungetchar(0); ! 726: CATCH ! 727: fixech(); ! 728: unix0(0); ! 729: ONERR ! 730: splitw = 0; ! 731: ungetchar(d); ! 732: vrepaint(cursor); ! 733: globp = oglobp; ! 734: return; ! 735: ENDCATCH ! 736: ungetchar(d); globp = oglobp; ! 737: addr = dot; ! 738: CATCH ! 739: vgoto(WECHO, 0); flusho(); ! 740: vremote(cnt, filter, 2); ! 741: ONERR ! 742: vdirty(0, LINES); ! 743: ENDCATCH ! 744: if (dot == zero && dol > zero) ! 745: dot = one; ! 746: splitw = 0; ! 747: notenam = ""; ! 748: /* ! 749: * BUG: we shouldn't be depending on what undap2 and undap1 are, ! 750: * since we may be inside a macro. What's really wanted is the ! 751: * number of lines we read from the filter. However, the mistake ! 752: * will be an overestimate so it only results in extra work, ! 753: * it shouldn't cause any real screwups. ! 754: */ ! 755: vreplace(vcline, cnt, undap2 - undap1); ! 756: dot = addr; ! 757: if (dot > dol) { ! 758: dot--; ! 759: vcline--; ! 760: } ! 761: vrepaint(NOSTR); ! 762: } ! 763: ! 764: /* ! 765: * Xdw exchanges dot and wdot if appropriate and also checks ! 766: * that wdot is reasonable. Its name comes from ! 767: * xchange dotand wdot ! 768: */ ! 769: xdw() ! 770: { ! 771: register char *cp; ! 772: register int cnt; ! 773: /* ! 774: register int notp = 0; ! 775: */ ! 776: ! 777: if (wdot == NOLINE || wdot < one || wdot > dol) { ! 778: beep(); ! 779: return (-1); ! 780: } ! 781: vsave(); ! 782: setLAST(); ! 783: if (dot > wdot) { ! 784: register line *addr; ! 785: ! 786: vcline -= dot - wdot; ! 787: addr = dot; dot = wdot; wdot = addr; ! 788: cp = cursor; cursor = wcursor; wcursor = cp; ! 789: } ! 790: /* ! 791: * If a region is specified but wcursor is at the begining ! 792: * of the last line, then we move it to be the end of the ! 793: * previous line (actually off the end). ! 794: */ ! 795: if (cursor && wcursor == linebuf && wdot > dot) { ! 796: wdot--; ! 797: getDOT(); ! 798: if (vpastwh(linebuf) >= cursor) ! 799: wcursor = 0; ! 800: else { ! 801: getline(*wdot); ! 802: wcursor = strend(linebuf); ! 803: getDOT(); ! 804: } ! 805: /* ! 806: * Should prepare in caller for possible dot == wdot. ! 807: */ ! 808: } ! 809: cnt = wdot - dot + 1; ! 810: if (vreg) { ! 811: vremote(cnt, YANKreg, vreg); ! 812: /* ! 813: if (notp) ! 814: notpart(vreg); ! 815: */ ! 816: } ! 817: ! 818: /* ! 819: * Kill buffer code. If delete operator is c or d, then save ! 820: * the region in numbered buffers. ! 821: * ! 822: * BUG: This may be somewhat inefficient due ! 823: * to the way named buffer are implemented, ! 824: * necessitating some optimization. ! 825: */ ! 826: vreg = 0; ! 827: if (any(op, "cd")) { ! 828: vremote(cnt, YANKreg, '1'); ! 829: /* ! 830: if (notp) ! 831: notpart('1'); ! 832: */ ! 833: } ! 834: return (cnt); ! 835: } ! 836: ! 837: /* ! 838: * Routine for vremote to call to implement shifts. ! 839: */ ! 840: vshift() ! 841: { ! 842: ! 843: shift(op, 1); ! 844: } ! 845: ! 846: /* ! 847: * Replace a single character with the next input character. ! 848: * A funny kind of insert. ! 849: */ ! 850: vrep(cnt) ! 851: register int cnt; ! 852: { ! 853: register int i, c; ! 854: ! 855: if (cnt > strlen(cursor)) { ! 856: beep(); ! 857: return; ! 858: } ! 859: i = column(cursor + cnt - 1); ! 860: vcursat(cursor); ! 861: doomed = i - cindent(); ! 862: if (!vglobp) { ! 863: c = getesc(); ! 864: if (c == 0) { ! 865: vfixcurs(); ! 866: return; ! 867: } ! 868: ungetkey(c); ! 869: } ! 870: CP(vutmp, linebuf); ! 871: if (FIXUNDO) ! 872: vundkind = VCHNG; ! 873: wcursor = cursor + cnt; ! 874: vUD1 = cursor; vUD2 = wcursor; ! 875: CP(cursor, wcursor); ! 876: prepapp(); ! 877: vappend('r', cnt, 0); ! 878: *lastcp++ = INS[0]; ! 879: setLAST(); ! 880: } ! 881: ! 882: /* ! 883: * Yank. ! 884: * ! 885: * Yanking to string registers occurs for free (essentially) ! 886: * in the routine xdw(). ! 887: */ ! 888: vyankit() ! 889: { ! 890: register int cnt; ! 891: ! 892: if (wdot) { ! 893: if ((cnt = xdw()) < 0) ! 894: return; ! 895: vremote(cnt, yank, 0); ! 896: setpk(); ! 897: notenam = "yank"; ! 898: if (FIXUNDO) ! 899: vundkind = VNONE; ! 900: DEL[0] = 0; ! 901: wdot = NOLINE; ! 902: if (notecnt <= vcnt - vcline && notecnt < value(REPORT)) ! 903: notecnt = 0; ! 904: vrepaint(cursor); ! 905: return; ! 906: } ! 907: takeout(DEL); ! 908: } ! 909: ! 910: /* ! 911: * Set pkill variables so a put can ! 912: * know how to put back partial text. ! 913: * This is necessary because undo needs the complete ! 914: * line images to be saved, while a put wants to trim ! 915: * the first and last lines. The compromise ! 916: * is for put to be more clever. ! 917: */ ! 918: setpk() ! 919: { ! 920: ! 921: if (wcursor) { ! 922: pkill[0] = cursor; ! 923: pkill[1] = wcursor; ! 924: } ! 925: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.