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