![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vput.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / ex|
Return to ex_vput.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / ex |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: #include "ex.h"
3: #include "ex_tty.h"
4: #include "ex_vis.h"
5:
6: /*
7: * Deal with the screen, clearing, cursor positioning, putting characters
8: * into the screen image, and deleting characters.
9: * Really hard stuff here is utilizing insert character operations
10: * on intelligent terminals which differs widely from terminal to terminal.
11: */
12: vclear()
13: {
14:
15: #ifdef ADEBUG
16: if (trace)
17: tfixnl(), fprintf(trace, "------\nvclear\n");
18: #endif
19: tputs(CL, LINES, putch);
20: destcol = 0;
21: outcol = 0;
22: destline = 0;
23: outline = 0;
24: if (inopen)
25: vclrbyte(vtube0, WCOLS * (WECHO - ZERO + 1));
26: }
27:
28: /*
29: * Clear memory.
30: */
31: vclrbyte(cp, i)
32: register char *cp;
33: register int i;
34: {
35:
36: if (i > 0)
37: do
38: *cp++ = 0;
39: while (--i != 0);
40: }
41:
42: /*
43: * Clear a physical display line, high level.
44: */
45: vclrlin(l, tp)
46: int l;
47: line *tp;
48: {
49:
50: vigoto(l, 0);
51: if ((hold & HOLDAT) == 0)
52: putchar(tp > dol ? ((UPPERCASE || HZ) ? '^' : '~') : '@');
53: if (state == HARDOPEN)
54: sethard();
55: vclreol();
56: }
57:
58: /*
59: * Clear to the end of the current physical line
60: */
61: vclreol()
62: {
63: register int i, j;
64: register char *tp;
65:
66: if (destcol == WCOLS)
67: return;
68: destline += destcol / WCOLS;
69: destcol %= WCOLS;
70: if (destline < 0 || destline > WECHO)
71: error("Internal error: vclreol");
72: i = WCOLS - destcol;
73: tp = vtube[destline] + destcol;
74: if (CE) {
75: if (IN && *tp || !ateopr()) {
76: vcsync();
77: vputp(CE, 1);
78: }
79: vclrbyte(tp, i);
80: return;
81: }
82: if (*tp == 0)
83: return;
84: while (i > 0 && (j = *tp & (QUOTE|TRIM))) {
85: if (j != ' ' && (j & QUOTE) == 0) {
86: destcol = WCOLS - i;
87: vputchar(' ');
88: }
89: --i, *tp++ = 0;
90: }
91: }
92:
93: /*
94: * Clear the echo line.
95: * If didphys then its been cleared physically (as
96: * a side effect of a clear to end of display, e.g.)
97: * so just do it logically.
98: * If work here is being held off, just remember, in
99: * heldech, if work needs to be done, don't do anything.
100: */
101: vclrech(didphys)
102: bool didphys;
103: {
104:
105: if (Peekkey == ATTN)
106: return;
107: if (hold & HOLDECH) {
108: heldech = !didphys;
109: return;
110: }
111: if (!didphys && (CD || CE)) {
112: splitw++;
113: /*
114: * If display is retained below, then MUST use CD or CE
115: * since we don't really know whats out there.
116: * Vigoto might decide (incorrectly) to do nothing.
117: */
118: if (DB)
119: vgoto(WECHO, 0), vputp(CD ? CD : CE, 1);
120: else
121: vigoto(WECHO, 0), vclreol();
122: splitw = 0;
123: didphys = 1;
124: }
125: if (didphys)
126: vclrbyte(vtube[WECHO], WCOLS);
127: heldech = 0;
128: }
129:
130: /*
131: * Fix the echo area for use, setting
132: * the state variable splitw so we wont rollup
133: * when we move the cursor there.
134: */
135: fixech()
136: {
137:
138: splitw++;
139: if (state != VISUAL && state != CRTOPEN) {
140: vclean();
141: vcnt = 0;
142: }
143: vgoto(WECHO, 0); flusho();
144: }
145:
146: /*
147: * Put the cursor ``before'' cp.
148: */
149: vcursbef(cp)
150: register char *cp;
151: {
152:
153: if (cp <= linebuf)
154: vgotoCL(value(NUMBER) << 3);
155: else
156: vgotoCL(column(cp - 1) - 1);
157: }
158:
159: /*
160: * Put the cursor ``at'' cp.
161: */
162: vcursat(cp)
163: register char *cp;
164: {
165:
166: if (cp <= linebuf && linebuf[0] == 0)
167: vgotoCL(value(NUMBER) << 3);
168: else
169: vgotoCL(column(cp - 1));
170: }
171:
172: /*
173: * Put the cursor ``after'' cp.
174: */
175: vcursaft(cp)
176: register char *cp;
177: {
178:
179: vgotoCL(column(cp));
180: }
181:
182: /*
183: * Fix the cursor to be positioned in the correct place
184: * to accept a command.
185: */
186: vfixcurs()
187: {
188:
189: vsetcurs(cursor);
190: }
191:
192: /*
193: * Compute the column position implied by the cursor at ``nc'',
194: * and move the cursor there.
195: */
196: vsetcurs(nc)
197: register char *nc;
198: {
199: register int col;
200:
201: col = column(nc);
202: if (linebuf[0])
203: col--;
204: vgotoCL(col);
205: cursor = nc;
206: }
207:
208: /*
209: * Move the cursor invisibly, i.e. only remember to do it.
210: */
211: vigoto(y, x)
212: int y, x;
213: {
214:
215: destline = y;
216: destcol = x;
217: }
218:
219: /*
220: * Move the cursor to the position implied by any previous
221: * vigoto (or low level hacking with destcol/destline as in readecho).
222: */
223: vcsync()
224: {
225:
226: vgoto(destline, destcol);
227: }
228:
229: /*
230: * Goto column x of the current line.
231: */
232: vgotoCL(x)
233: register int x;
234: {
235:
236: if (splitw)
237: vgoto(WECHO, x);
238: else
239: vgoto(LINE(vcline), x);
240: }
241:
242: /*
243: * Invisible goto column x of current line.
244: */
245: vigotoCL(x)
246: register int x;
247: {
248:
249: if (splitw)
250: vigoto(WECHO, x);
251: else
252: vigoto(LINE(vcline), x);
253: }
254:
255: /*
256: * Move cursor to line y, column x, handling wraparound and scrolling.
257: */
258: vgoto(y, x)
259: register int y, x;
260: {
261: register char *tp;
262: register int c;
263:
264: /*
265: * Fold the possibly too large value of x.
266: */
267: if (x >= WCOLS) {
268: y += x / WCOLS;
269: x %= WCOLS;
270: }
271: if (y < 0)
272: error("Internal error: vgoto");
273: if (outcol >= WCOLS) {
274: if (AM) {
275: outline += outcol / WCOLS;
276: outcol %= WCOLS;
277: } else
278: outcol = WCOLS - 1;
279: }
280:
281: /*
282: * In a hardcopy or glass crt open, print the stuff
283: * implied by a motion, or backspace.
284: */
285: if (state == HARDOPEN || state == ONEOPEN) {
286: if (y != outline)
287: error("Line too long for open");
288: if (x + 1 < outcol - x || (outcol > x && !BS))
289: destcol = 0, fgoto();
290: tp = vtube[WBOT] + outcol;
291: while (outcol != x)
292: if (outcol < x) {
293: if (*tp == 0)
294: *tp = ' ';
295: c = *tp++ & TRIM;
296: vputc(c && (!OS || EO) ? c : ' '), outcol++;
297: } else {
298: if (BC)
299: vputp(BC, 0);
300: else
301: vputc('\b');
302: outcol--;
303: }
304: destcol = outcol = x;
305: destline = outline;
306: return;
307: }
308:
309: /*
310: * If the destination position implies a scroll, do it.
311: */
312: destline = y;
313: if (destline > WBOT && (!splitw || destline > WECHO)) {
314: endim();
315: vrollup(destline);
316: }
317:
318: /*
319: * If there really is a motion involved, do it.
320: * The check here is an optimization based on profiling.
321: */
322: destcol = x;
323: if ((destline - outline) * WCOLS != destcol - outcol) {
324: if (!MI)
325: endim();
326: fgoto();
327: }
328: }
329:
330: /*
331: * This is the hardest code in the editor, and deals with insert modes
332: * on different kinds of intelligent terminals. The complexity is due
333: * to the cross product of three factors:
334: *
335: * 1. Lines may display as more than one segment on the screen.
336: * 2. There are 2 kinds of intelligent terminal insert modes.
337: * 3. Tabs squash when you insert characters in front of them,
338: * in a way in which current intelligent terminals don't handle.
339: *
340: * The two kinds of terminals are typified by the DM2500 or HP2645 for
341: * one and the CONCEPT-100 or the FOX for the other.
342: *
343: * The first (HP2645) kind has an insert mode where the characters
344: * fall off the end of the line and the screen is shifted rigidly
345: * no matter how the display came about.
346: *
347: * The second (CONCEPT-100) kind comes from terminals which are designed
348: * for forms editing and which distinguish between blanks and ``spaces''
349: * on the screen, spaces being like blank, but never having had
350: * and data typed into that screen position (since, e.g. a clear operation
351: * like clear screen). On these terminals, when you insert a character,
352: * the characters from where you are to the end of the screen shift
353: * over till a ``space'' is found, and the null character there gets
354: * eaten up.
355: *
356: *
357: * The code here considers the line as consisting of several parts
358: * the first part is the ``doomed'' part, i.e. a part of the line
359: * which is being typed over. Next comes some text up to the first
360: * following tab. The tab is the next segment of the line, and finally
361: * text after the tab.
362: *
363: * We have to consider each of these segments and the effect of the
364: * insertion of a character on them. On terminals like HP2645's we
365: * must simulate a multi-line insert mode using the primitive one
366: * line insert mode. If we are inserting in front of a tab, we have
367: * to either delete characters from the tab or insert white space
368: * (when the tab reaches a new spot where it gets larger) before we
369: * insert the new character.
370: *
371: * On a terminal like a CONCEPT our strategy is to make all
372: * blanks be displayed, while trying to keep the screen having ``spaces''
373: * for portions of tabs. In this way the terminal hardward does some
374: * of the hacking for compression of tabs, although this tends to
375: * disappear as you work on the line and spaces change into blanks.
376: *
377: * There are a number of boundary conditions (like typing just before
378: * the first following tab) where we can avoid a lot of work. Most
379: * of them have to be dealt with explicitly because performance is
380: * much, much worse if we don't.
381: *
382: * A final thing which is hacked here is two flavors of insert mode.
383: * Datamedia's do this by an insert mode which you enter and leave
384: * and by having normal motion character operate differently in this
385: * mode, notably by having a newline insert a line on the screen in
386: * this mode. This generally means it is unsafe to move around
387: * the screen ignoring the fact that we are in this mode.
388: * This is possible on some terminals, and wins big (e.g. HP), so
389: * we encode this as a ``can move in insert capability'' mi,
390: * and terminals which have it can do insert mode with much less
391: * work when tabs are present following the cursor on the current line.
392: */
393:
394: /*
395: * Routine to expand a tab, calling the normal Outchar routine
396: * to put out each implied character. Note that we call outchar
397: * with a QUOTE. We use QUOTE internally to represent a position
398: * which is part of the expansion of a tab.
399: */
400: vgotab()
401: {
402: register int i = (LINE(vcline) - destline) * WCOLS + destcol;
403:
404: do
405: (*Outchar)(QUOTE);
406: while (++i % value(TABSTOP));
407: }
408:
409: /*
410: * Variables for insert mode.
411: */
412: int linend; /* The column position of end of line */
413: int tabstart; /* Column of start of first following tab */
414: int tabend; /* Column of end of following tabs */
415: int tabsize; /* Size of the following tabs */
416: int tabslack; /* Number of ``spaces'' in following tabs */
417: int inssiz; /* Number of characters to be inserted */
418: int inscol; /* Column where insertion is taking place */
419: int shft; /* Amount tab expansion shifted rest of line */
420: int slakused; /* This much of tabslack will be used up */
421:
422: /*
423: * This routine MUST be called before insert mode is run,
424: * and brings all segments of the current line to the top
425: * of the screen image buffer so it is easier for us to
426: * maniuplate them.
427: */
428: vprepins()
429: {
430: register int i;
431: register char *cp = vtube0;
432:
433: for (i = 0; i < DEPTH(vcline); i++) {
434: vmaktop(LINE(vcline) + i, cp);
435: cp += WCOLS;
436: }
437: }
438:
439: vmaktop(p, cp)
440: register int p;
441: char *cp;
442: {
443: register int i;
444: char temp[TUBECOLS];
445:
446: if (vtube[p] == cp)
447: return;
448: for (i = ZERO; i <= WECHO; i++)
449: if (vtube[i] == cp) {
450: copy(temp, vtube[i], WCOLS);
451: copy(vtube[i], vtube[p], WCOLS);
452: copy(vtube[p], temp, WCOLS);
453: vtube[i] = vtube[p];
454: vtube[p] = cp;
455: return;
456: }
457: error("Line too long");
458: }
459:
460: /*
461: * Insert character c at current cursor position.
462: * Multi-character inserts occur only as a result
463: * of expansion of tabs (i.e. inssize == 1 except
464: * for tabs) and code assumes this in several place
465: * to make life simpler.
466: */
467: vinschar(c)
468: char c;
469: {
470: register int i;
471: register char *tp;
472:
473: if ((!IM || !EI) && ((hold & HOLDQIK) || !value(REDRAW) || value(SLOWOPEN))) {
474: /*
475: * Don't want to try to use terminal
476: * insert mode, or to try to fake it.
477: * Just put the character out; the screen
478: * will probably be wrong but we will fix it later.
479: */
480: if (c == '\t') {
481: vgotab();
482: return;
483: }
484: vputchar(c);
485: if (DEPTH(vcline) * WCOLS + !value(REDRAW) >
486: (destline - LINE(vcline)) * WCOLS + destcol)
487: return;
488: /*
489: * The next line is about to be clobbered
490: * make space for another segment of this line
491: * (on an intelligent terminal) or just remember
492: * that next line was clobbered (on a dumb one
493: * if we don't care to redraw the tail.
494: */
495: if (AL) {
496: vnpins(0);
497: } else {
498: c = LINE(vcline) + DEPTH(vcline);
499: if (c < LINE(vcline + 1) || c > WBOT)
500: return;
501: i = destcol;
502: vinslin(c, 1, vcline);
503: DEPTH(vcline)++;
504: vigoto(c, i);
505: vprepins();
506: }
507: return;
508: }
509: /*
510: * Compute the number of positions in the line image of the
511: * current line. This is done from the physical image
512: * since that is faster. Note that we have no memory
513: * from insertion to insertion so that routines which use
514: * us don't have to worry about moving the cursor around.
515: */
516: if (*vtube0 == 0)
517: linend = 0;
518: else {
519: /*
520: * Search backwards for a non-null character
521: * from the end of the displayed line.
522: */
523: i = WCOLS * DEPTH(vcline);
524: if (i == 0)
525: i = WCOLS;
526: tp = vtube0 + i;
527: while (*--tp == 0)
528: if (--i == 0)
529: break;
530: linend = i;
531: }
532:
533: /*
534: * We insert at a position based on the physical location
535: * of the output cursor.
536: */
537: inscol = destcol + (destline - LINE(vcline)) * WCOLS;
538: if (c == '\t') {
539: /*
540: * Characters inserted from a tab must be
541: * remembered as being part of a tab, but we can't
542: * use QUOTE here since we really need to print blanks.
543: * QUOTE|' ' is the representation of this.
544: */
545: inssiz = value(TABSTOP) - inscol % value(TABSTOP);
546: c = ' ' | QUOTE;
547: } else
548: inssiz = 1;
549:
550: /*
551: * If the text to be inserted is less than the number
552: * of doomed positions, then we don't need insert mode,
553: * rather we can just typeover.
554: */
555: if (inssiz <= doomed) {
556: endim();
557: if (inscol != linend)
558: doomed -= inssiz;
559: do
560: vputchar(c);
561: while (--inssiz);
562: return;
563: }
564:
565: /*
566: * Have to really do some insertion, thus
567: * stake out the bounds of the first following
568: * group of tabs, computing starting position,
569: * ending position, and the number of ``spaces'' therein
570: * so we can tell how much it will squish.
571: */
572: tp = vtube0 + inscol;
573: for (i = inscol; i < linend; i++)
574: if (*tp++ & QUOTE) {
575: --tp;
576: break;
577: }
578: tabstart = tabend = i;
579: tabslack = 0;
580: while (tabend < linend) {
581: i = *tp++;
582: if ((i & QUOTE) == 0)
583: break;
584: if ((i & TRIM) == 0)
585: tabslack++;
586: tabsize++;
587: tabend++;
588: }
589: tabsize = tabend - tabstart;
590:
591: /*
592: * For HP's and DM's, e.g. tabslack has no meaning.
593: */
594: if (!IN)
595: tabslack = 0;
596: #ifdef IDEBUG
597: if (trace) {
598: fprintf(trace, "inscol %d, inssiz %d, tabstart %d, ",
599: inscol, inssiz, tabstart);
600: fprintf(trace, "tabend %d, tabslack %d, linend %d\n",
601: tabend, tabslack, linend);
602: }
603: #endif
604:
605: /*
606: * The real work begins.
607: */
608: slakused = 0;
609: shft = 0;
610: if (tabsize) {
611: /*
612: * There are tabs on this line.
613: * If they need to expand, then the rest of the line
614: * will have to be shifted over. In this case,
615: * we will need to make sure there are no ``spaces''
616: * in the rest of the line (on e.g. CONCEPT-100)
617: * and then grab another segment on the screen if this
618: * line is now deeper. We then do the shift
619: * implied by the insertion.
620: */
621: if (inssiz >= doomed + value(TABSTOP) - tabstart % value(TABSTOP)) {
622: if (IN)
623: vrigid();
624: vneedpos(value(TABSTOP));
625: vishft();
626: }
627: } else if (inssiz > doomed)
628: /*
629: * No tabs, but line may still get deeper.
630: */
631: vneedpos(inssiz - doomed);
632: /*
633: * Now put in the inserted characters.
634: */
635: viin(c);
636:
637: /*
638: * Now put the cursor in its final resting place.
639: */
640: destline = LINE(vcline);
641: destcol = inscol + inssiz;
642: vcsync();
643: }
644:
645: /*
646: * Rigidify the rest of the line after the first
647: * group of following tabs, typing blanks over ``spaces''.
648: */
649: vrigid()
650: {
651: register int col;
652: register char *tp = vtube0 + tabend;
653:
654: for (col = tabend; col < linend; col++)
655: if ((*tp++ & TRIM) == 0) {
656: endim();
657: vgotoCL(col);
658: vputchar(' ' | QUOTE);
659: }
660: }
661:
662: /*
663: * We need cnt more positions on this line.
664: * Open up new space on the screen (this may in fact be a
665: * screen rollup).
666: *
667: * On a dumb terminal we may infact redisplay the rest of the
668: * screen here brute force to keep it pretty.
669: */
670: vneedpos(cnt)
671: int cnt;
672: {
673: register int d = DEPTH(vcline);
674: register int rmdr = d * WCOLS - linend;
675:
676: if (cnt <= rmdr - IN)
677: return;
678: endim();
679: vnpins(1);
680: }
681:
682: vnpins(dosync)
683: int dosync;
684: {
685: register int d = DEPTH(vcline);
686: register int e;
687:
688: e = LINE(vcline) + DEPTH(vcline);
689: if (e < LINE(vcline + 1)) {
690: vigoto(e, 0);
691: vclreol();
692: return;
693: }
694: DEPTH(vcline)++;
695: if (e < WECHO) {
696: e = vglitchup(vcline, d);
697: vigoto(e, 0); vclreol();
698: if (dosync) {
699: Outchar = vputchar;
700: vsync(e + 1);
701: Outchar = vinschar;
702: }
703: } else {
704: vup1();
705: vigoto(WBOT, 0);
706: vclreol();
707: }
708: vprepins();
709: }
710:
711: /*
712: * Do the shift of the next tabstop implied by
713: * insertion so it expands.
714: */
715: vishft()
716: {
717: int tshft = 0;
718: int j;
719: register int i;
720: register char *tp = vtube0;
721: register char *up;
722: short oldhold = hold;
723:
724: shft = value(TABSTOP);
725: hold |= HOLDPUPD;
726: if (!IM && !EI) {
727: /*
728: * Dumb terminals are easy, we just have
729: * to retype the text.
730: */
731: vigotoCL(tabend + shft);
732: up = tp + tabend;
733: for (i = tabend; i < linend; i++)
734: vputchar(*up++);
735: } else if (IN) {
736: /*
737: * CONCEPT-like terminals do most of the work for us,
738: * we don't have to muck with simulation of multi-line
739: * insert mode. Some of the shifting may come for free
740: * also if the tabs don't have enough slack to take up
741: * all the inserted characters.
742: */
743: i = shft;
744: slakused = inssiz - doomed;
745: if (slakused > tabslack) {
746: i -= slakused - tabslack;
747: slakused -= tabslack;
748: }
749: if (i > 0 && tabend != linend) {
750: tshft = i;
751: vgotoCL(tabend);
752: goim();
753: do
754: vputchar(' ' | QUOTE);
755: while (--i);
756: }
757: } else {
758: /*
759: * HP and Datamedia type terminals have to have multi-line
760: * insert faked. Hack each segment after where we are
761: * (going backwards to where we are.) We then can
762: * hack the segment where the end of the first following
763: * tab group is.
764: */
765: for (j = DEPTH(vcline) - 1; j > (tabend + shft) / WCOLS; j--) {
766: vgotoCL(j * WCOLS);
767: goim();
768: up = tp + j * WCOLS - shft;
769: i = shft;
770: do
771: vputchar(*up++);
772: while (--i);
773: }
774: vigotoCL(tabstart);
775: i = shft - (inssiz - doomed);
776: if (i > 0) {
777: tabslack = inssiz - doomed;
778: vcsync();
779: goim();
780: do
781: vputchar(' ');
782: while (--i);
783: }
784: }
785: /*
786: * Now do the data moving in the internal screen
787: * image which is common to all three cases.
788: */
789: tp += linend;
790: up = tp + shft;
791: i = linend - tabend;
792: if (i > 0)
793: do
794: *--up = *--tp;
795: while (--i);
796: if (IN && tshft) {
797: i = tshft;
798: do
799: *--up = ' ' | QUOTE;
800: while (--i);
801: }
802: hold = oldhold;
803: }
804:
805: /*
806: * Now do the insert of the characters (finally).
807: */
808: viin(c)
809: char c;
810: {
811: register char *tp, *up;
812: register int i, j;
813: register bool noim = 0;
814: int remdoom;
815: short oldhold = hold;
816:
817: hold |= HOLDPUPD;
818: if (tabsize && (IM && EI) && inssiz - doomed > tabslack)
819: /*
820: * There is a tab out there which will be affected
821: * by the insertion since there aren't enough doomed
822: * characters to take up all the insertion and we do
823: * have insert mode capability.
824: */
825: if (inscol + doomed == tabstart) {
826: /*
827: * The end of the doomed characters sits right at the
828: * start of the tabs, then we don't need to use insert
829: * mode; unless the tab has already been expanded
830: * in which case we MUST use insert mode.
831: */
832: slakused = 0;
833: noim = !shft;
834: } else {
835: /*
836: * The last really special case to handle is case
837: * where the tab is just sitting there and doesn't
838: * have enough slack to let the insertion take
839: * place without shifting the rest of the line
840: * over. In this case we have to go out and
841: * delete some characters of the tab before we start
842: * or the answer will be wrong, as the rest of the
843: * line will have been shifted. This code means
844: * that terminals with only insert chracter (no
845: * delete character) won't work correctly.
846: */
847: i = inssiz - doomed - tabslack - slakused;
848: i %= value(TABSTOP);
849: if (i > 0) {
850: vgotoCL(tabstart);
851: godm();
852: for (i = inssiz - doomed - tabslack; i > 0; i--)
853: vputp(DC, DEPTH(vcline));
854: enddm();
855: }
856: }
857:
858: /*
859: * Now put out the characters of the actual insertion.
860: */
861: vigotoCL(inscol);
862: remdoom = doomed;
863: for (i = inssiz; i > 0; i--) {
864: if (remdoom > 0) {
865: remdoom--;
866: endim();
867: } else if (noim)
868: endim();
869: else if (IM && EI) {
870: vcsync();
871: goim();
872: }
873: vputchar(c);
874: }
875:
876: if (!IM || !EI) {
877: /*
878: * We are a dumb terminal; brute force update
879: * the rest of the line; this is very much an n^^2 process,
880: * and totally unreasonable at low speed.
881: *
882: * You asked for it, you get it.
883: */
884: tp = vtube0 + inscol + doomed;
885: for (i = inscol + doomed; i < tabstart; i++)
886: vputchar(*tp++);
887: hold = oldhold;
888: vigotoCL(tabstart + inssiz - doomed);
889: for (i = tabsize - (inssiz - doomed) + shft; i > 0; i--)
890: vputchar(' ' | QUOTE);
891: } else {
892: if (!IN) {
893: /*
894: * On terminals without multi-line
895: * insert in the hardware, we must go fix the segments
896: * between the inserted text and the following
897: * tabs, if they are on different lines.
898: *
899: * Aaargh.
900: */
901: tp = vtube0;
902: for (j = (inscol + inssiz - 1) / WCOLS + 1;
903: j <= (tabstart + inssiz - doomed - 1) / WCOLS; j++) {
904: vgotoCL(j * WCOLS);
905: i = inssiz - doomed;
906: up = tp + j * WCOLS - i;
907: goim();
908: do
909: vputchar(*up++);
910: while (--i && *up);
911: }
912: } else {
913: /*
914: * On terminals with multi line inserts,
915: * life is simpler, just reflect eating of
916: * the slack.
917: */
918: tp = vtube0 + tabend;
919: for (i = tabsize - (inssiz - doomed); i >= 0; i--) {
920: if ((*--tp & (QUOTE|TRIM)) == QUOTE) {
921: --tabslack;
922: if (tabslack >= slakused)
923: continue;
924: }
925: *tp = ' ' | QUOTE;
926: }
927: }
928: /*
929: * Blank out the shifted positions to be tab positions.
930: */
931: if (shft) {
932: tp = vtube0 + tabend + shft;
933: for (i = tabsize - (inssiz - doomed) + shft; i > 0; i--)
934: if ((*--tp & QUOTE) == 0)
935: *tp = ' ' | QUOTE;
936: }
937: }
938:
939: /*
940: * Finally, complete the screen image update
941: * to reflect the insertion.
942: */
943: hold = oldhold;
944: tp = vtube0 + tabstart; up = tp + inssiz - doomed;
945: for (i = tabstart; i > inscol + doomed; i--)
946: *--up = *--tp;
947: for (i = inssiz; i > 0; i--)
948: *--up = c;
949: doomed = 0;
950: }
951:
952: /*
953: * Go into ``delete mode''. If the
954: * sequence which goes into delete mode
955: * is the same as that which goes into insert
956: * mode, then we are in delete mode already.
957: */
958: godm()
959: {
960:
961: if (insmode) {
962: if (eq(DM, IM))
963: return;
964: endim();
965: }
966: vputp(DM, 0);
967: }
968:
969: /*
970: * If we are coming out of delete mode, but
971: * delete and insert mode end with the same sequence,
972: * it wins to pretend we are now in insert mode,
973: * since we will likely want to be there again soon
974: * if we just moved over to delete space from part of
975: * a tab (above).
976: */
977: enddm()
978: {
979:
980: if (eq(DM, IM)) {
981: insmode = 1;
982: return;
983: }
984: vputp(ED, 0);
985: }
986:
987: /*
988: * In and out of insert mode.
989: * Note that the code here demands that there be
990: * a string for insert mode (the null string) even
991: * if the terminal does all insertions a single character
992: * at a time, since it branches based on whether IM is null.
993: */
994: goim()
995: {
996:
997: if (!insmode)
998: vputp(IM, 0);
999: insmode = 1;
1000: }
1001:
1002: endim()
1003: {
1004:
1005: if (insmode) {
1006: vputp(EI, 0);
1007: insmode = 0;
1008: }
1009: }
1010:
1011: /*
1012: * Put the character c on the screen at the current cursor position.
1013: * This routine handles wraparound and scrolling and understands not
1014: * to roll when splitw is set, i.e. we are working in the echo area.
1015: * There is a bunch of hacking here dealing with the difference between
1016: * QUOTE, QUOTE|' ', and ' ' for CONCEPT-100 like terminals, and also
1017: * code to deal with terminals which overstrike, including CRT's where
1018: * you can erase overstrikes with some work. CRT's which do underlining
1019: * implicitly which has to be erased (like CONCEPTS) are also handled.
1020: */
1021: vputchar(c)
1022: register int c;
1023: {
1024: register char *tp;
1025: register int d;
1026:
1027: c &= (QUOTE|TRIM);
1028: #ifdef TRACE
1029: if (trace)
1030: tracec(c);
1031: #endif
1032: /* Patch to fix problem of >79 chars on echo line: don't echo extras */
1033: if (destcol >= WCOLS-1 && splitw && destline == WECHO)
1034: return;
1035: if (destcol >= WCOLS) {
1036: destline += destcol / WCOLS;
1037: destcol %= WCOLS;
1038: }
1039: if (destline > WBOT && (!splitw || destline > WECHO))
1040: vrollup(destline);
1041: tp = vtube[destline] + destcol;
1042: switch (c) {
1043:
1044: case '\t':
1045: vgotab();
1046: return;
1047:
1048: case ' ':
1049: /*
1050: * We can get away without printing a space in a number
1051: * of cases, but not always. We get away with doing nothing
1052: * if we are not in insert mode, and not on a CONCEPT-100
1053: * like terminal, and either not in hardcopy open or in hardcopy
1054: * open on a terminal with no overstriking, provided,
1055: * in all cases, that nothing has ever been displayed
1056: * at this position. Ugh.
1057: */
1058: if (!insmode && !IN && (state != HARDOPEN || OS) && (*tp&TRIM) == 0) {
1059: *tp = ' ';
1060: destcol++;
1061: return;
1062: }
1063: goto def;
1064:
1065: case QUOTE:
1066: if (insmode) {
1067: /*
1068: * When in insert mode, tabs have to expand
1069: * to real, printed blanks.
1070: */
1071: c = ' ' | QUOTE;
1072: goto def;
1073: }
1074: if (*tp == 0) {
1075: /*
1076: * A ``space''.
1077: */
1078: if ((hold & HOLDPUPD) == 0)
1079: *tp = QUOTE;
1080: destcol++;
1081: return;
1082: }
1083: /*
1084: * A ``space'' ontop of a part of a tab.
1085: */
1086: if (*tp & QUOTE) {
1087: destcol++;
1088: return;
1089: }
1090: c = ' ' | QUOTE;
1091: /* fall into ... */
1092:
1093: def:
1094: default:
1095: d = *tp & TRIM;
1096: /*
1097: * Now get away with doing nothing if the characters
1098: * are the same, provided we are not in insert mode
1099: * and if we are in hardopen, that the terminal has overstrike.
1100: */
1101: if (d == (c & TRIM) && !insmode && (state != HARDOPEN || OS)) {
1102: if ((hold & HOLDPUPD) == 0)
1103: *tp = c;
1104: destcol++;
1105: return;
1106: }
1107: /*
1108: * Backwards looking optimization.
1109: * The low level cursor motion routines will use
1110: * a cursor motion right sequence to step 1 character
1111: * right. On, e.g., a DM3025A this is 2 characters
1112: * and printing is noticeably slower at 300 baud.
1113: * Since the low level routines are not allowed to use
1114: * spaces for positioning, we discover the common
1115: * case of a single space here and force a space
1116: * to be printed.
1117: */
1118: if (destcol == outcol + 1 && tp[-1] == ' ' && outline == destline) {
1119: vputc(' ');
1120: outcol++;
1121: }
1122:
1123: /*
1124: * This is an inline expansion a call to vcsync() dictated
1125: * by high frequency in a profile.
1126: */
1127: if (outcol != destcol || outline != destline)
1128: vgoto(destline, destcol);
1129:
1130: /*
1131: * Deal with terminals which have overstrike.
1132: * We handle erasing general overstrikes, erasing
1133: * underlines on terminals (such as CONCEPTS) which
1134: * do underlining correctly automatically (e.g. on nroff
1135: * output), and remembering, in hardcopy mode,
1136: * that we have overstruct something.
1137: */
1138: if (!insmode && d && d != ' ' && d != (c & TRIM)) {
1139: if (EO && (OS || UL && (c == '_' || d == '_'))) {
1140: vputc(' ');
1141: outcol++, destcol++;
1142: back1();
1143: } else
1144: rubble = 1;
1145: }
1146:
1147: /*
1148: * Unless we are just bashing characters around for
1149: * inner working of insert mode, update the display.
1150: */
1151: if ((hold & HOLDPUPD) == 0)
1152: *tp = c;
1153:
1154: /*
1155: * In insert mode, put out the IC sequence, padded
1156: * based on the depth of the current line.
1157: * A terminal which had no real insert mode, rather
1158: * opening a character position at a time could do this.
1159: * Actually should use depth to end of current line
1160: * but this rarely matters.
1161: */
1162: if (insmode)
1163: vputp(IC, DEPTH(vcline));
1164: vputc(c & TRIM);
1165:
1166: /*
1167: * In insert mode, IP is a post insert pad.
1168: */
1169: if (insmode)
1170: vputp(IP, DEPTH(vcline));
1171: destcol++, outcol++;
1172:
1173: /*
1174: * CONCEPT braindamage in early models: after a wraparound
1175: * the next newline is eaten. It's hungry so we just
1176: * feed it now rather than worrying about it.
1177: */
1178: if (XN && outcol % WCOLS == 0)
1179: vputc('\n');
1180: }
1181: }
1182:
1183: /*
1184: * Delete display positions stcol through endcol.
1185: * Amount of use of special terminal features here is limited.
1186: */
1187: physdc(stcol, endcol)
1188: int stcol, endcol;
1189: {
1190: register char *tp, *up;
1191: char *tpe;
1192: register int i;
1193: register int nc = endcol - stcol;
1194:
1195: #ifdef IDEBUG
1196: if (trace)
1197: tfixnl(), fprintf(trace, "physdc(%d, %d)\n", stcol, endcol);
1198: #endif
1199: if (!DC || nc <= 0)
1200: return;
1201: if (IN) {
1202: /*
1203: * CONCEPT-100 like terminal.
1204: * If there are any ``spaces'' in the material to be
1205: * deleted, then this is too hard, just retype.
1206: */
1207: vprepins();
1208: up = vtube0 + stcol;
1209: i = nc;
1210: do
1211: if ((*up++ & (QUOTE|TRIM)) == QUOTE)
1212: return;
1213: while (--i);
1214: i = 2 * nc;
1215: do
1216: if (*up == 0 || (*up++ & QUOTE) == QUOTE)
1217: return;
1218: while (--i);
1219: vgotoCL(stcol);
1220: } else {
1221: /*
1222: * HP like delete mode.
1223: * Compute how much text we are moving over by deleting.
1224: * If it appears to be faster to just retype
1225: * the line, do nothing and that will be done later.
1226: * We are assuming 2 output characters per deleted
1227: * characters and that clear to end of line is available.
1228: */
1229: i = stcol / WCOLS;
1230: if (i != endcol / WCOLS)
1231: return;
1232: i += LINE(vcline);
1233: stcol %= WCOLS;
1234: endcol %= WCOLS;
1235: up = vtube[i]; tp = up + endcol; tpe = up + WCOLS;
1236: while (tp < tpe && *tp)
1237: tp++;
1238: if (tp - (up + stcol) < 2 * nc)
1239: return;
1240: vgoto(i, stcol);
1241: }
1242:
1243: /*
1244: * Go into delete mode and do the actual delete.
1245: * Padding is on DC itself.
1246: */
1247: godm();
1248: for (i = nc; i > 0; i--)
1249: vputp(DC, DEPTH(vcline));
1250: vputp(ED, 0);
1251:
1252: /*
1253: * Straighten up.
1254: * With CONCEPT like terminals, characters are pulled left
1255: * from first following null. HP like terminals shift rest of
1256: * this (single physical) line rigidly.
1257: */
1258: if (IN) {
1259: up = vtube0 + stcol;
1260: tp = vtube0 + endcol;
1261: while (i = *tp++) {
1262: if ((i & (QUOTE|TRIM)) == QUOTE)
1263: break;
1264: *up++ = i;
1265: }
1266: do
1267: *up++ = i;
1268: while (--nc);
1269: } else {
1270: copy(up + stcol, up + endcol, WCOLS - endcol);
1271: vclrbyte(tpe - nc, nc);
1272: }
1273: }
1274:
1275: #ifdef TRACE
1276: tfixnl()
1277: {
1278:
1279: if (trubble || techoin)
1280: fprintf(trace, "\n");
1281: trubble = 0, techoin = 0;
1282: }
1283:
1284: tvliny()
1285: {
1286: register int i;
1287:
1288: if (!trace)
1289: return;
1290: tfixnl();
1291: fprintf(trace, "vcnt = %d, vcline = %d, vliny = ", vcnt, vcline);
1292: for (i = 0; i <= vcnt; i++) {
1293: fprintf(trace, "%d", LINE(i));
1294: if (FLAGS(i) & VDIRT)
1295: fprintf(trace, "*");
1296: if (DEPTH(i) != 1)
1297: fprintf(trace, "<%d>", DEPTH(i));
1298: if (i < vcnt)
1299: fprintf(trace, " ");
1300: }
1301: fprintf(trace, "\n");
1302: }
1303:
1304: tracec(c)
1305: char c;
1306: {
1307:
1308: if (!techoin)
1309: trubble = 1;
1310: if (c == ESCAPE)
1311: fprintf(trace, "$");
1312: else if (c < ' ' || c == DELETE)
1313: fprintf(trace, "^%c", ctlof(c));
1314: else
1315: fprintf(trace, "%c", c);
1316: }
1317: #endif
1318:
1319: /*
1320: * Put a character with possible tracing.
1321: */
1322: vputch(c)
1323: int c;
1324: {
1325:
1326: #ifdef TRACE
1327: if (trace)
1328: tracec(c);
1329: #endif
1330: vputc(c);
1331: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.