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