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