![[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] / 43BSDReno / usr.bin / ex|
Return to ex_put.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / 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.12 (Berkeley) 5/19/89";
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 (*Put_char)() = 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 = Put_char;
43: Put_char = 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: ex_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: ex_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: ex_putchar(*cp++);
164: if (!inopen)
165: ex_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 (Put_char == 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: ex_putchar(c)
221: int c;
222: {
223:
224: (*Put_char)(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: #ifndef vms
775: write(1, obuf, obp - obuf);
776: #else
777: vms_write(1, obuf, obp - obuf);
778: #endif
779: obp = obuf;
780: }
781: }
782:
783: putnl()
784: {
785:
786: ex_putchar('\n');
787: }
788:
789: ex_putS(cp)
790: char *cp;
791: {
792:
793: if (cp == NULL)
794: return;
795: while (*cp)
796: putch(*cp++);
797: }
798:
799:
800: putch(c)
801: int c;
802: {
803:
804: #ifdef OLD3BTTY /* mjm */
805: if(c == '\n') /* mjm: Fake "\n\r" for '\n' til fix in 3B firmware */
806: putch('\r'); /* mjm: vi does "stty -icanon" => -onlcr !! */
807: #endif
808: *obp++ = c & 0177;
809: if (obp >= &obuf[sizeof obuf])
810: flusho();
811: }
812:
813: /*
814: * Miscellaneous routines related to output.
815: */
816:
817: /*
818: * Put with padding
819: */
820: putpad(cp)
821: char *cp;
822: {
823:
824: flush();
825: tputs(cp, 0, putch);
826: }
827:
828: /*
829: * Set output through normal command mode routine.
830: */
831: setoutt()
832: {
833:
834: Outchar = termchar;
835: }
836:
837: /*
838: * Printf (temporarily) in list mode.
839: */
840: /*VARARGS1*/
841: lprintf(cp, dp)
842: char *cp, *dp;
843: {
844: register int (*P)();
845:
846: P = setlist(1);
847: ex_printf(cp, dp);
848: Put_char = P;
849: }
850:
851: /*
852: * Newline + flush.
853: */
854: putNFL()
855: {
856:
857: putnl();
858: flush();
859: }
860:
861: /*
862: * Try to start -nl mode.
863: */
864: pstart()
865: {
866:
867: if (NONL)
868: return;
869: if (!value(OPTIMIZE))
870: return;
871: if (ruptible == 0 || pfast)
872: return;
873: fgoto();
874: flusho();
875: pfast = 1;
876: normtty++;
877: #ifndef USG3TTY
878: tty.sg_flags = normf & ~(ECHO|XTABS|CRMOD);
879: #else
880: tty = normf;
881: tty.c_oflag &= ~(ONLCR|TAB3);
882: tty.c_lflag &= ~ECHO;
883: #endif
884: ex_sTTY(1);
885: }
886:
887: /*
888: * Stop -nl mode.
889: */
890: pstop()
891: {
892:
893: if (inopen)
894: return;
895: phadnl = 0;
896: linp = linb;
897: draino();
898: normal(normf);
899: pfast &= ~1;
900: }
901:
902: /*
903: * Prep tty for open mode.
904: */
905: ttymode
906: ostart()
907: {
908: ttymode f;
909:
910: if (!intty)
911: error("Open and visual must be used interactively");
912: ex_gTTY(1);
913: normtty++;
914: #ifndef USG3TTY
915: f = tty.sg_flags;
916: tty.sg_flags = (normf &~ (ECHO|XTABS|CRMOD)) |
917: # ifdef CBREAK
918: CBREAK;
919: # else
920: RAW;
921: # endif
922: # ifdef TIOCGETC
923: ttcharoff();
924: # endif
925: #else
926: f = tty;
927: tty = normf;
928: tty.c_iflag &= ~ICRNL;
929: tty.c_lflag &= ~(ECHO|ICANON);
930: tty.c_oflag &= ~(TAB3|ONLCR);
931: tty.c_cc[VMIN] = 1;
932: tty.c_cc[VTIME] = 1;
933: ttcharoff();
934: #endif
935: ex_sTTY(1);
936: tostart();
937: pfast |= 2;
938: return (f);
939: }
940:
941: /* actions associated with putting the terminal in open mode */
942: tostart()
943: {
944: putpad(VS);
945: putpad(KS);
946: if (!value(MESG)) {
947: if (ttynbuf[0] == 0) {
948: register char *tn;
949: if ((tn=ttyname(2)) == NULL &&
950: (tn=ttyname(1)) == NULL &&
951: (tn=ttyname(0)) == NULL)
952: ttynbuf[0] = 1;
953: else
954: strcpy(ttynbuf, tn);
955: }
956: if (ttynbuf[0] != 1) {
957: struct stat sbuf;
958: stat(ttynbuf, &sbuf);
959: ttymesg = sbuf.st_mode & 0777;
960: chmod(ttynbuf,
961: #ifdef UCBV7
962: /*
963: * This applies to the UCB V7 Pdp-11 system with the
964: * -u write option only.
965: */
966: 0611 /* 11 = urgent only allowed */
967: #else
968: 0600
969: #endif
970: );
971: }
972: }
973: }
974:
975: /*
976: * Turn off start/stop chars if they aren't the default ^S/^Q.
977: * This is so idiots who make esc their start/stop don't lose.
978: * We always turn off quit since datamedias send ^\ for their
979: * right arrow key.
980: */
981: #ifdef TIOCGETC
982: ttcharoff()
983: {
984: nttyc.t_quitc = '\377';
985: if (nttyc.t_startc != CTRL('q'))
986: nttyc.t_startc = '\377';
987: if (nttyc.t_stopc != CTRL('s'))
988: nttyc.t_stopc = '\377';
989: # ifdef TIOCLGET
990: nlttyc.t_suspc = '\377'; /* ^Z */
991: nlttyc.t_dsuspc = '\377'; /* ^Y */
992: nlttyc.t_flushc = '\377'; /* ^O */
993: nlttyc.t_lnextc = '\377'; /* ^V */
994: # endif
995: }
996: #endif
997:
998: #ifdef USG3TTY
999: ttcharoff()
1000: {
1001: tty.c_cc[VQUIT] = '\377';
1002: # ifdef VSTART
1003: /*
1004: * The following is sample code if USG ever lets people change
1005: * their start/stop chars. As long as they can't we can't get
1006: * into trouble so we just leave them alone.
1007: */
1008: if (tty.c_cc[VSTART] != CTRL('q'))
1009: tty.c_cc[VSTART] = '\377';
1010: if (tty.c_cc[VSTOP] != CTRL('s'))
1011: tty.c_cc[VSTOP] = '\377';
1012: # endif
1013: }
1014: #endif
1015:
1016: /*
1017: * Stop open, restoring tty modes.
1018: */
1019: ostop(f)
1020: ttymode f;
1021: {
1022:
1023: #ifndef USG3TTY
1024: pfast = (f & CRMOD) == 0;
1025: #else
1026: pfast = (f.c_oflag & ONLCR) == 0;
1027: #endif
1028: termreset(), fgoto(), flusho();
1029: normal(f);
1030: tostop();
1031: }
1032:
1033: /* Actions associated with putting the terminal in the right mode. */
1034: tostop()
1035: {
1036: putpad(VE);
1037: putpad(KE);
1038: if (!value(MESG) && ttynbuf[0]>1)
1039: chmod(ttynbuf, ttymesg);
1040: }
1041:
1042: #ifndef CBREAK
1043: /*
1044: * Into cooked mode for interruptibility.
1045: */
1046: vcook()
1047: {
1048:
1049: tty.sg_flags &= ~RAW;
1050: ex_sTTY(1);
1051: }
1052:
1053: /*
1054: * Back into raw mode.
1055: */
1056: vraw()
1057: {
1058:
1059: tty.sg_flags |= RAW;
1060: ex_sTTY(1);
1061: }
1062: #endif
1063:
1064: /*
1065: * Restore flags to normal state f.
1066: */
1067: normal(f)
1068: ttymode f;
1069: {
1070:
1071: if (normtty > 0) {
1072: ignore(setty(f));
1073: normtty--;
1074: }
1075: }
1076:
1077: /*
1078: * Straight set of flags to state f.
1079: */
1080: ttymode
1081: setty(f)
1082: ttymode f;
1083: {
1084: #ifndef USG3TTY
1085: register int ot = tty.sg_flags;
1086: #else
1087: ttymode ot;
1088: ot = tty;
1089: #endif
1090:
1091: #ifndef USG3TTY
1092: # ifdef TIOCGETC
1093: if (f == normf) {
1094: nttyc = ottyc;
1095: # ifdef TIOCLGET
1096: nlttyc = olttyc;
1097: # endif
1098: } else
1099: ttcharoff();
1100: # endif
1101: tty.sg_flags = f;
1102: #else
1103: if (tty.c_lflag & ICANON)
1104: ttcharoff();
1105: tty = f;
1106: #endif
1107: ex_sTTY(1);
1108: return (ot);
1109: }
1110:
1111: ex_gTTY(i)
1112: int i;
1113: {
1114:
1115: #ifndef USG3TTY
1116: ignore(ioctl(i, TIOCGETP, &tty));
1117: # ifdef TIOCGETC
1118: ioctl(i, TIOCGETC, (char *) &ottyc);
1119: nttyc = ottyc;
1120: # endif
1121: # ifdef TIOCGLTC
1122: ioctl(i, TIOCGLTC, (char *) &olttyc);
1123: nlttyc = olttyc;
1124: # endif
1125: #else
1126: ioctl(i, TCGETA, (char *) &tty);
1127: #endif
1128: }
1129:
1130: /*
1131: * ex_sTTY: set the tty modes on file descriptor i to be what's
1132: * currently in global "tty". (Also use nttyc if needed.)
1133: */
1134: ex_sTTY(i)
1135: int i;
1136: {
1137:
1138: #ifndef USG3TTY
1139: # ifdef USG
1140: /* Bug in USG tty driver, put out a DEL as a patch. */
1141: if (tty.sg_ospeed >= B1200)
1142: write(1, "\377", 1);
1143: # endif
1144:
1145: # ifdef TIOCSETN
1146: /* Don't flush typeahead if we don't have to */
1147: ioctl(i, TIOCSETN, (char *) &tty);
1148: # else
1149: /* We have to. Too bad. */
1150: stty(i, &tty);
1151: # endif
1152:
1153: # ifdef TIOCGETC
1154: /* Update the other random chars while we're at it. */
1155: ioctl(i, TIOCSETC, (char *) &nttyc);
1156: # endif
1157: # ifdef TIOCSLTC
1158: ioctl(i, TIOCSLTC, (char *) &nlttyc);
1159: # endif
1160:
1161: #else
1162: /* USG 3 very simple: just set everything */
1163: ioctl(i, TCSETAW, (char *) &tty);
1164: #endif
1165: }
1166:
1167: /*
1168: * Print newline, or blank if in open/visual
1169: */
1170: noonl()
1171: {
1172:
1173: ex_putchar(Outchar != termchar ? ' ' : '\n');
1174: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.