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