![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_put.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_put.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_put.c 7.9 (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: * Terminal driving and line formatting routines.
17: * Basic motion optimizations are done here as well
18: * as formatting of lines (printing of control characters,
19: * line numbering and the like).
20: */
21:
22: /*
23: * The routines outchar, putchar and pline are actually
24: * variables, and these variables point at the current definitions
25: * of the routines. See the routine setflav.
26: * We sometimes make outchar be routines which catch the characters
27: * to be printed, e.g. if we want to see how long a line is.
28: * During open/visual, outchar and putchar will be set to
29: * routines in the file ex_vput.c (vputchar, vinschar, etc.).
30: */
31: int (*Outchar)() = termchar;
32: int (*Putchar)() = normchar;
33: int (*Pline)() = normline;
34:
35: int (*
36: setlist(t))()
37: bool t;
38: {
39: register int (*P)();
40:
41: listf = t;
42: P = Putchar;
43: Putchar = t ? listchar : normchar;
44: return (P);
45: }
46:
47: int (*
48: setnumb(t))()
49: bool t;
50: {
51: register int (*P)();
52:
53: numberf = t;
54: P = Pline;
55: Pline = t ? numbline : normline;
56: return (P);
57: }
58:
59: /*
60: * Format c for list mode; leave things in common
61: * with normal print mode to be done by normchar.
62: */
63: listchar(c)
64: register short c;
65: {
66:
67: c &= (TRIM|QUOTE);
68: switch (c) {
69:
70: case '\t':
71: case '\b':
72: outchar('^');
73: c = ctlof(c);
74: break;
75:
76: case '\n':
77: break;
78:
79: case '\n' | QUOTE:
80: outchar('$');
81: break;
82:
83: default:
84: if (c & QUOTE)
85: break;
86: if (c < ' ' && c != '\n' || c == DELETE)
87: outchar('^'), c = ctlof(c);
88: break;
89: }
90: normchar(c);
91: }
92:
93: /*
94: * Format c for printing. Handle funnies of upper case terminals
95: * and crocky hazeltines which don't have ~.
96: */
97: normchar(c)
98: register short c;
99: {
100: register char *colp;
101:
102: c &= (TRIM|QUOTE);
103: if (c == '~' && HZ) {
104: normchar('\\');
105: c = '^';
106: }
107: if (c & QUOTE)
108: switch (c) {
109:
110: case ' ' | QUOTE:
111: case '\b' | QUOTE:
112: break;
113:
114: case QUOTE:
115: return;
116:
117: default:
118: c &= TRIM;
119: }
120: else if (c < ' ' && (c != '\b' || !OS) && c != '\n' && c != '\t' || c == DELETE)
121: putchar('^'), c = ctlof(c);
122: else if (UPPERCASE)
123: if (isupper(c)) {
124: outchar('\\');
125: c = tolower(c);
126: } else {
127: colp = "({)}!|^~'`";
128: while (*colp++)
129: if (c == *colp++) {
130: outchar('\\');
131: c = colp[-2];
132: break;
133: }
134: }
135: outchar(c);
136: }
137:
138: /*
139: * Print a line with a number.
140: */
141: numbline(i)
142: int i;
143: {
144:
145: if (shudclob)
146: slobber(' ');
147: printf("%6d ", i);
148: normline();
149: }
150:
151: /*
152: * Normal line output, no numbering.
153: */
154: normline()
155: {
156: register char *cp;
157:
158: if (shudclob)
159: slobber(linebuf[0]);
160: /* pdp-11 doprnt is not reentrant so can't use "printf" here
161: in case we are tracing */
162: for (cp = linebuf; *cp;)
163: putchar(*cp++);
164: if (!inopen)
165: putchar('\n' | QUOTE);
166: }
167:
168: /*
169: * Given c at the beginning of a line, determine whether
170: * the printing of the line will erase or otherwise obliterate
171: * the prompt which was printed before. If it won't, do it now.
172: */
173: slobber(c)
174: int c;
175: {
176:
177: shudclob = 0;
178: switch (c) {
179:
180: case '\t':
181: if (Putchar == listchar)
182: return;
183: break;
184:
185: default:
186: return;
187:
188: case ' ':
189: case 0:
190: break;
191: }
192: if (OS)
193: return;
194: flush();
195: putch(' ');
196: if (BC)
197: tputs(BC, 0, putch);
198: else
199: putch('\b');
200: }
201:
202: /*
203: * The output buffer is initialized with a useful error
204: * message so we don't have to keep it in data space.
205: */
206: static char linb[66];
207: char *linp = linb;
208:
209: /*
210: * Phadnl records when we have already had a complete line ending with \n.
211: * If another line starts without a flush, and the terminal suggests it,
212: * we switch into -nl mode so that we can send lineffeeds to avoid
213: * a lot of spacing.
214: */
215: static bool phadnl;
216:
217: /*
218: * Indirect to current definition of putchar.
219: */
220: putchar(c)
221: int c;
222: {
223:
224: (*Putchar)(c);
225: }
226:
227: /*
228: * Termchar routine for command mode.
229: * Watch for possible switching to -nl mode.
230: * Otherwise flush into next level of buffering when
231: * small buffer fills or at a newline.
232: */
233: termchar(c)
234: int c;
235: {
236:
237: if (pfast == 0 && phadnl)
238: pstart();
239: if (c == '\n')
240: phadnl = 1;
241: else if (linp >= &linb[63])
242: flush1();
243: *linp++ = c;
244: if (linp >= &linb[63]) {
245: fgoto();
246: flush1();
247: }
248: }
249:
250: flush()
251: {
252:
253: flush1();
254: flush2();
255: }
256:
257: /*
258: * Flush from small line buffer into output buffer.
259: * Work here is destroying motion into positions, and then
260: * letting fgoto do the optimized motion.
261: */
262: flush1()
263: {
264: register char *lp;
265: register short c;
266:
267: *linp = 0;
268: lp = linb;
269: while (*lp)
270: switch (c = *lp++) {
271:
272: case '\r':
273: destline += destcol / COLUMNS;
274: destcol = 0;
275: continue;
276:
277: case '\b':
278: if (destcol)
279: destcol--;
280: continue;
281:
282: case ' ':
283: destcol++;
284: continue;
285:
286: case '\t':
287: destcol += value(TABSTOP) - destcol % value(TABSTOP);
288: continue;
289:
290: case '\n':
291: destline += destcol / COLUMNS + 1;
292: if (destcol != 0 && destcol % COLUMNS == 0)
293: destline--;
294: destcol = 0;
295: continue;
296:
297: default:
298: fgoto();
299: for (;;) {
300: if (AM == 0 && outcol == COLUMNS)
301: fgoto();
302: c &= TRIM;
303: putch(c);
304: if (c == '\b') {
305: outcol--;
306: destcol--;
307: } else if (c >= ' ' && c != DELETE) {
308: outcol++;
309: destcol++;
310: if (XN && outcol % COLUMNS == 0)
311: putch('\r'), putch('\n');
312: }
313: c = *lp++;
314: if (c <= ' ')
315: break;
316: }
317: --lp;
318: continue;
319: }
320: linp = linb;
321: }
322:
323: flush2()
324: {
325:
326: fgoto();
327: flusho();
328: pstop();
329: }
330:
331: /*
332: * Sync the position of the output cursor.
333: * Most work here is rounding for terminal boundaries getting the
334: * column position implied by wraparound or the lack thereof and
335: * rolling up the screen to get destline on the screen.
336: */
337: fgoto()
338: {
339: register int l, c;
340:
341: if (destcol > COLUMNS - 1) {
342: destline += destcol / COLUMNS;
343: destcol %= COLUMNS;
344: }
345: if (outcol > COLUMNS - 1) {
346: l = (outcol + 1) / COLUMNS;
347: outline += l;
348: outcol %= COLUMNS;
349: if (AM == 0) {
350: while (l > 0) {
351: if (pfast)
352: if (xCR)
353: tputs(xCR, 0, putch);
354: else
355: putch('\r');
356: if (xNL)
357: tputs(xNL, 0, putch);
358: else
359: putch('\n');
360: l--;
361: }
362: outcol = 0;
363: }
364: if (outline > LINES - 1) {
365: destline -= outline - (LINES - 1);
366: outline = LINES - 1;
367: }
368: }
369: if (destline > LINES - 1) {
370: l = destline;
371: destline = LINES - 1;
372: if (outline < LINES - 1) {
373: c = destcol;
374: if (pfast == 0 && (!CA || holdcm))
375: destcol = 0;
376: fgoto();
377: destcol = c;
378: }
379: while (l > LINES - 1) {
380: /*
381: * The following linefeed (or simulation thereof)
382: * is supposed to scroll up the screen, since we
383: * are on the bottom line. We make the assumption
384: * that linefeed will scroll. If ns is in the
385: * capability list this won't work. We should
386: * probably have an sc capability but sf will
387: * generally take the place if it works.
388: *
389: * Superbee glitch: in the middle of the screen we
390: * have to use esc B (down) because linefeed screws up
391: * in "Efficient Paging" (what a joke) mode (which is
392: * essential in some SB's because CRLF mode puts garbage
393: * in at end of memory), but you must use linefeed to
394: * scroll since down arrow won't go past memory end.
395: * I turned this off after recieving Paul Eggert's
396: * Superbee description which wins better.
397: */
398: if (xNL /* && !XB */ && pfast)
399: tputs(xNL, 0, putch);
400: else
401: putch('\n');
402: l--;
403: if (pfast == 0)
404: outcol = 0;
405: }
406: }
407: if (destline < outline && !(CA && !holdcm || UP != NOSTR))
408: destline = outline;
409: if (CA && !holdcm)
410: if (plod(costCM) > 0)
411: plod(0);
412: else
413: tputs(tgoto(CM, destcol, destline), 0, putch);
414: else
415: plod(0);
416: outline = destline;
417: outcol = destcol;
418: }
419:
420: /*
421: * Tab to column col by flushing and then setting destcol.
422: * Used by "set all".
423: */
424: tab(col)
425: int col;
426: {
427:
428: flush1();
429: destcol = col;
430: }
431:
432: /*
433: * Move (slowly) to destination.
434: * Hard thing here is using home cursor on really deficient terminals.
435: * Otherwise just use cursor motions, hacking use of tabs and overtabbing
436: * and backspace.
437: */
438:
439: static int plodcnt, plodflg;
440:
441: plodput(c)
442: {
443:
444: if (plodflg)
445: plodcnt--;
446: else
447: putch(c);
448: }
449:
450: plod(cnt)
451: {
452: register int i, j, k;
453: register int soutcol, soutline;
454:
455: plodcnt = plodflg = cnt;
456: soutcol = outcol;
457: soutline = outline;
458: /*
459: * Consider homing and moving down/right from there, vs moving
460: * directly with local motions to the right spot.
461: */
462: if (HO) {
463: /*
464: * i is the cost to home and tab/space to the right to
465: * get to the proper column. This assumes ND space costs
466: * 1 char. So i+destcol is cost of motion with home.
467: */
468: if (GT)
469: i = (destcol / value(HARDTABS)) + (destcol % value(HARDTABS));
470: else
471: i = destcol;
472: /*
473: * j is cost to move locally without homing
474: */
475: if (destcol >= outcol) { /* if motion is to the right */
476: j = destcol / value(HARDTABS) - outcol / value(HARDTABS);
477: if (GT && j)
478: j += destcol % value(HARDTABS);
479: else
480: j = destcol - outcol;
481: } else
482: /* leftward motion only works if we can backspace. */
483: if (outcol - destcol <= i && (BS || BC))
484: i = j = outcol - destcol; /* cheaper to backspace */
485: else
486: j = i + 1; /* impossibly expensive */
487:
488: /* k is the absolute value of vertical distance */
489: k = outline - destline;
490: if (k < 0)
491: k = -k;
492: j += k;
493:
494: /*
495: * Decision. We may not have a choice if no UP.
496: */
497: if (i + destline < j || (!UP && destline < outline)) {
498: /*
499: * Cheaper to home. Do it now and pretend it's a
500: * regular local motion.
501: */
502: tputs(HO, 0, plodput);
503: outcol = outline = 0;
504: } else if (LL) {
505: /*
506: * Quickly consider homing down and moving from there.
507: * Assume cost of LL is 2.
508: */
509: k = (LINES - 1) - destline;
510: if (i + k + 2 < j && (k<=0 || UP)) {
511: tputs(LL, 0, plodput);
512: outcol = 0;
513: outline = LINES - 1;
514: }
515: }
516: } else
517: /*
518: * No home and no up means it's impossible, so we return an
519: * incredibly big number to make cursor motion win out.
520: */
521: if (!UP && destline < outline)
522: return (500);
523: if (GT)
524: i = destcol % value(HARDTABS)
525: + destcol / value(HARDTABS);
526: else
527: i = destcol;
528: /*
529: if (BT && outcol > destcol && (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
530: j *= (k = strlen(BT));
531: if ((k += (destcol&7)) > 4)
532: j += 8 - (destcol&7);
533: else
534: j += k;
535: } else
536: */
537: j = outcol - destcol;
538: /*
539: * If we will later need a \n which will turn into a \r\n by
540: * the system or the terminal, then don't bother to try to \r.
541: */
542: if ((NONL || !pfast) && outline < destline)
543: goto dontcr;
544: /*
545: * If the terminal will do a \r\n and there isn't room for it,
546: * then we can't afford a \r.
547: */
548: if (NC && outline >= destline)
549: goto dontcr;
550: /*
551: * If it will be cheaper, or if we can't back up, then send
552: * a return preliminarily.
553: */
554: if (j > i + 1 || outcol > destcol && !BS && !BC) {
555: /*
556: * BUG: this doesn't take the (possibly long) length
557: * of xCR into account.
558: */
559: if (xCR)
560: tputs(xCR, 0, plodput);
561: else
562: plodput('\r');
563: if (NC) {
564: if (xNL)
565: tputs(xNL, 0, plodput);
566: else
567: plodput('\n');
568: outline++;
569: }
570: outcol = 0;
571: }
572: dontcr:
573: /* Move down, if necessary, until we are at the desired line */
574: while (outline < destline) {
575: j = destline - outline;
576: if (j > costDP && DOWN_PARM) {
577: /* Win big on Tek 4025 */
578: tputs(tgoto(DOWN_PARM, 0, j), j, plodput);
579: outline += j;
580: }
581: else {
582: outline++;
583: if (xNL && pfast)
584: tputs(xNL, 0, plodput);
585: else
586: plodput('\n');
587: }
588: if (plodcnt < 0)
589: goto out;
590: if (NONL || pfast == 0)
591: outcol = 0;
592: }
593: if (BT)
594: k = strlen(BT); /* should probably be cost(BT) and moved out */
595: /* Move left, if necessary, to desired column */
596: while (outcol > destcol) {
597: if (plodcnt < 0)
598: goto out;
599: if (BT && !insmode && outcol - destcol > 4+k) {
600: tputs(BT, 0, plodput);
601: outcol--;
602: outcol -= outcol % value(HARDTABS); /* outcol &= ~7; */
603: continue;
604: }
605: j = outcol - destcol;
606: if (j > costLP && LEFT_PARM) {
607: tputs(tgoto(LEFT_PARM, 0, j), j, plodput);
608: outcol -= j;
609: }
610: else {
611: outcol--;
612: if (BC)
613: tputs(BC, 0, plodput);
614: else
615: plodput('\b');
616: }
617: }
618: /* Move up, if necessary, to desired row */
619: while (outline > destline) {
620: j = outline - destline;
621: if (UP_PARM && j > 1) {
622: /* Win big on Tek 4025 */
623: tputs(tgoto(UP_PARM, 0, j), j, plodput);
624: outline -= j;
625: }
626: else {
627: outline--;
628: tputs(UP, 0, plodput);
629: }
630: if (plodcnt < 0)
631: goto out;
632: }
633: /*
634: * Now move to the right, if necessary. We first tab to
635: * as close as we can get.
636: */
637: if (GT && !insmode && destcol - outcol > 1) {
638: /* tab to right as far as possible without passing col */
639: for (;;) {
640: i = tabcol(outcol, value(HARDTABS));
641: if (i > destcol)
642: break;
643: if (TA)
644: tputs(TA, 0, plodput);
645: else
646: plodput('\t');
647: outcol = i;
648: }
649: /* consider another tab and then some backspaces */
650: if (destcol - outcol > 4 && i < COLUMNS && (BC || BS)) {
651: if (TA)
652: tputs(TA, 0, plodput);
653: else
654: plodput('\t');
655: outcol = i;
656: /*
657: * Back up. Don't worry about LEFT_PARM because
658: * it's never more than 4 spaces anyway.
659: */
660: while (outcol > destcol) {
661: outcol--;
662: if (BC)
663: tputs(BC, 0, plodput);
664: else
665: plodput('\b');
666: }
667: }
668: }
669: /*
670: * We've tabbed as much as possible. If we still need to go
671: * further (not exact or can't tab) space over. This is a
672: * very common case when moving to the right with space.
673: */
674: while (outcol < destcol) {
675: j = destcol - outcol;
676: if (j > costRP && RIGHT_PARM) {
677: /*
678: * This probably happens rarely, if at all.
679: * It seems mainly useful for ANSI terminals
680: * with no hardware tabs, and I don't know
681: * of any such terminal at the moment.
682: */
683: tputs(tgoto(RIGHT_PARM, 0, j), j, plodput);
684: outcol += j;
685: }
686: else {
687: /*
688: * move one char to the right. We don't use ND space
689: * because it's better to just print the char we are
690: * moving over. There are various exceptions, however.
691: * If !inopen, vtube contains garbage. If the char is
692: * a null or a tab we want to print a space. Other
693: * random chars we use space for instead, too.
694: */
695: if (!inopen || vtube[outline]==NULL ||
696: (i=vtube[outline][outcol]) < ' ')
697: i = ' ';
698: if(i & QUOTE) /* mjm: no sign extension on 3B */
699: i = ' ';
700: if (insmode && ND)
701: tputs(ND, 0, plodput);
702: else
703: plodput(i);
704: outcol++;
705: }
706: if (plodcnt < 0)
707: goto out;
708: }
709: out:
710: if (plodflg) {
711: outcol = soutcol;
712: outline = soutline;
713: }
714: return(plodcnt);
715: }
716:
717: /*
718: * An input line arrived.
719: * Calculate new (approximate) screen line position.
720: * Approximate because kill character echoes newline with
721: * no feedback and also because of long input lines.
722: */
723: noteinp()
724: {
725:
726: outline++;
727: if (outline > LINES - 1)
728: outline = LINES - 1;
729: destline = outline;
730: destcol = outcol = 0;
731: }
732:
733: /*
734: * Something weird just happened and we
735: * lost track of whats happening out there.
736: * Since we cant, in general, read where we are
737: * we just reset to some known state.
738: * On cursor addressible terminals setting to unknown
739: * will force a cursor address soon.
740: */
741: termreset()
742: {
743:
744: endim();
745: if (TI) /* otherwise it flushes anyway, and 'set tty=dumb' vomits */
746: putpad(TI); /*adb change -- emit terminal initial sequence */
747: destcol = 0;
748: destline = LINES - 1;
749: if (CA) {
750: outcol = UKCOL;
751: outline = UKCOL;
752: } else {
753: outcol = destcol;
754: outline = destline;
755: }
756: }
757:
758: /*
759: * Low level buffering, with the ability to drain
760: * buffered output without printing it.
761: */
762: char *obp = obuf;
763:
764: draino()
765: {
766:
767: obp = obuf;
768: }
769:
770: flusho()
771: {
772:
773: if (obp != obuf) {
774: write(1, obuf, obp - obuf);
775: obp = obuf;
776: }
777: }
778:
779: putnl()
780: {
781:
782: putchar('\n');
783: }
784:
785: putS(cp)
786: char *cp;
787: {
788:
789: if (cp == NULL)
790: return;
791: while (*cp)
792: putch(*cp++);
793: }
794:
795:
796: putch(c)
797: int c;
798: {
799:
800: #ifdef OLD3BTTY /* mjm */
801: if(c == '\n') /* mjm: Fake "\n\r" for '\n' til fix in 3B firmware */
802: putch('\r'); /* mjm: vi does "stty -icanon" => -onlcr !! */
803: #endif
804: *obp++ = c & 0177;
805: if (obp >= &obuf[sizeof obuf])
806: flusho();
807: }
808:
809: /*
810: * Miscellaneous routines related to output.
811: */
812:
813: /*
814: * Put with padding
815: */
816: putpad(cp)
817: char *cp;
818: {
819:
820: flush();
821: tputs(cp, 0, putch);
822: }
823:
824: /*
825: * Set output through normal command mode routine.
826: */
827: setoutt()
828: {
829:
830: Outchar = termchar;
831: }
832:
833: /*
834: * Printf (temporarily) in list mode.
835: */
836: /*VARARGS2*/
837: lprintf(cp, dp)
838: char *cp, *dp;
839: {
840: register int (*P)();
841:
842: P = setlist(1);
843: printf(cp, dp);
844: Putchar = P;
845: }
846:
847: /*
848: * Newline + flush.
849: */
850: putNFL()
851: {
852:
853: putnl();
854: flush();
855: }
856:
857: /*
858: * Try to start -nl mode.
859: */
860: pstart()
861: {
862:
863: if (NONL)
864: return;
865: if (!value(OPTIMIZE))
866: return;
867: if (ruptible == 0 || pfast)
868: return;
869: fgoto();
870: flusho();
871: pfast = 1;
872: normtty++;
873: #ifndef USG3TTY
874: tty.sg_flags = normf & ~(ECHO|XTABS|CRMOD);
875: #else
876: tty = normf;
877: tty.c_oflag &= ~(ONLCR|TAB3);
878: tty.c_lflag &= ~ECHO;
879: #endif
880: sTTY(1);
881: }
882:
883: /*
884: * Stop -nl mode.
885: */
886: pstop()
887: {
888:
889: if (inopen)
890: return;
891: phadnl = 0;
892: linp = linb;
893: draino();
894: normal(normf);
895: pfast &= ~1;
896: }
897:
898: /*
899: * Prep tty for open mode.
900: */
901: ttymode
902: ostart()
903: {
904: ttymode f;
905:
906: if (!intty)
907: error("Open and visual must be used interactively");
908: gTTY(1);
909: normtty++;
910: #ifndef USG3TTY
911: f = tty.sg_flags;
912: tty.sg_flags = (normf &~ (ECHO|XTABS|CRMOD)) |
913: # ifdef CBREAK
914: CBREAK;
915: # else
916: RAW;
917: # endif
918: # ifdef TIOCGETC
919: ttcharoff();
920: # endif
921: #else
922: f = tty;
923: tty = normf;
924: tty.c_iflag &= ~ICRNL;
925: tty.c_lflag &= ~(ECHO|ICANON);
926: tty.c_oflag &= ~(TAB3|ONLCR);
927: tty.c_cc[VMIN] = 1;
928: tty.c_cc[VTIME] = 1;
929: ttcharoff();
930: #endif
931: sTTY(1);
932: tostart();
933: pfast |= 2;
934: return (f);
935: }
936:
937: /* actions associated with putting the terminal in open mode */
938: tostart()
939: {
940: putpad(VS);
941: putpad(KS);
942: if (!value(MESG)) {
943: if (ttynbuf[0] == 0) {
944: register char *tn;
945: if ((tn=ttyname(2)) == NULL &&
946: (tn=ttyname(1)) == NULL &&
947: (tn=ttyname(0)) == NULL)
948: ttynbuf[0] = 1;
949: else
950: strcpy(ttynbuf, tn);
951: }
952: if (ttynbuf[0] != 1) {
953: struct stat sbuf;
954: stat(ttynbuf, &sbuf);
955: ttymesg = sbuf.st_mode & 0777;
956: chmod(ttynbuf,
957: #ifdef UCBV7
958: /*
959: * This applies to the UCB V7 Pdp-11 system with the
960: * -u write option only.
961: */
962: 0611 /* 11 = urgent only allowed */
963: #else
964: 0600
965: #endif
966: );
967: }
968: }
969: }
970:
971: /*
972: * Turn off start/stop chars if they aren't the default ^S/^Q.
973: * This is so idiots who make esc their start/stop don't lose.
974: * We always turn off quit since datamedias send ^\ for their
975: * right arrow key.
976: */
977: #ifdef TIOCGETC
978: ttcharoff()
979: {
980: nttyc.t_quitc = '\377';
981: if (nttyc.t_startc != CTRL(q))
982: nttyc.t_startc = '\377';
983: if (nttyc.t_stopc != CTRL(s))
984: nttyc.t_stopc = '\377';
985: # ifdef TIOCLGET
986: nlttyc.t_suspc = '\377'; /* ^Z */
987: nlttyc.t_dsuspc = '\377'; /* ^Y */
988: nlttyc.t_flushc = '\377'; /* ^O */
989: nlttyc.t_lnextc = '\377'; /* ^V */
990: # endif
991: }
992: #endif
993:
994: #ifdef USG3TTY
995: ttcharoff()
996: {
997: tty.c_cc[VQUIT] = '\377';
998: # ifdef VSTART
999: /*
1000: * The following is sample code if USG ever lets people change
1001: * their start/stop chars. As long as they can't we can't get
1002: * into trouble so we just leave them alone.
1003: */
1004: if (tty.c_cc[VSTART] != CTRL(q))
1005: tty.c_cc[VSTART] = '\377';
1006: if (tty.c_cc[VSTOP] != CTRL(s))
1007: tty.c_cc[VSTOP] = '\377';
1008: # endif
1009: }
1010: #endif
1011:
1012: /*
1013: * Stop open, restoring tty modes.
1014: */
1015: ostop(f)
1016: ttymode f;
1017: {
1018:
1019: #ifndef USG3TTY
1020: pfast = (f & CRMOD) == 0;
1021: #else
1022: pfast = (f.c_oflag & ONLCR) == 0;
1023: #endif
1024: termreset(), fgoto(), flusho();
1025: normal(f);
1026: tostop();
1027: }
1028:
1029: /* Actions associated with putting the terminal in the right mode. */
1030: tostop()
1031: {
1032: putpad(VE);
1033: putpad(KE);
1034: if (!value(MESG) && ttynbuf[0]>1)
1035: chmod(ttynbuf, ttymesg);
1036: }
1037:
1038: #ifndef CBREAK
1039: /*
1040: * Into cooked mode for interruptibility.
1041: */
1042: vcook()
1043: {
1044:
1045: tty.sg_flags &= ~RAW;
1046: sTTY(1);
1047: }
1048:
1049: /*
1050: * Back into raw mode.
1051: */
1052: vraw()
1053: {
1054:
1055: tty.sg_flags |= RAW;
1056: sTTY(1);
1057: }
1058: #endif
1059:
1060: /*
1061: * Restore flags to normal state f.
1062: */
1063: normal(f)
1064: ttymode f;
1065: {
1066:
1067: if (normtty > 0) {
1068: setty(f);
1069: normtty--;
1070: }
1071: }
1072:
1073: /*
1074: * Straight set of flags to state f.
1075: */
1076: ttymode
1077: setty(f)
1078: ttymode f;
1079: {
1080: #ifndef USG3TTY
1081: register int ot = tty.sg_flags;
1082: #else
1083: ttymode ot;
1084: ot = tty;
1085: #endif
1086:
1087: #ifndef USG3TTY
1088: if (f == normf) {
1089: nttyc = ottyc;
1090: # ifdef TIOCLGET
1091: nlttyc = olttyc;
1092: # endif
1093: } else
1094: ttcharoff();
1095: tty.sg_flags = f;
1096: #else
1097: if (tty.c_lflag & ICANON)
1098: ttcharoff();
1099: tty = f;
1100: #endif
1101: sTTY(1);
1102: return (ot);
1103: }
1104:
1105: gTTY(i)
1106: int i;
1107: {
1108:
1109: #ifndef USG3TTY
1110: ignore(gtty(i, &tty));
1111: # ifdef TIOCGETC
1112: ioctl(i, TIOCGETC, &ottyc);
1113: nttyc = ottyc;
1114: # endif
1115: # ifdef TIOCGLTC
1116: ioctl(i, TIOCGLTC, &olttyc);
1117: nlttyc = olttyc;
1118: # endif
1119: #else
1120: ioctl(i, TCGETA, &tty);
1121: #endif
1122: }
1123:
1124: /*
1125: * sTTY: set the tty modes on file descriptor i to be what's
1126: * currently in global "tty". (Also use nttyc if needed.)
1127: */
1128: sTTY(i)
1129: int i;
1130: {
1131:
1132: #ifndef USG3TTY
1133: # ifdef USG
1134: /* Bug in USG tty driver, put out a DEL as a patch. */
1135: if (tty.sg_ospeed >= B1200)
1136: write(1, "\377", 1);
1137: # endif
1138:
1139: # ifdef TIOCSETN
1140: /* Don't flush typeahead if we don't have to */
1141: ioctl(i, TIOCSETN, &tty);
1142: # else
1143: /* We have to. Too bad. */
1144: stty(i, &tty);
1145: # endif
1146:
1147: # ifdef TIOCGETC
1148: /* Update the other random chars while we're at it. */
1149: ioctl(i, TIOCSETC, &nttyc);
1150: # endif
1151: # ifdef TIOCSLTC
1152: ioctl(i, TIOCSLTC, &nlttyc);
1153: # endif
1154:
1155: #else
1156: /* USG 3 very simple: just set everything */
1157: ioctl(i, TCSETAW, &tty);
1158: #endif
1159: }
1160:
1161: /*
1162: * Print newline, or blank if in open/visual
1163: */
1164: noonl()
1165: {
1166:
1167: putchar(Outchar != termchar ? ' ' : '\n');
1168: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.