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