![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ttynew.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / sys / dev|
Return to ttynew.c CVS log | Up to [CSRG BSD Unix] / 40BSD / sys / dev |
1.1 root 1: /* ttynew.c 4.3 11/9/80 */
2:
3: /*
4: * New version of tty driver, supported
5: * as NTTYDISC. Adapted from a tty.c written
6: * by J.E.Kulp of IIASA, Austria (jekulp@mc)
7: */
8: #include "../h/param.h"
9: #include "../h/systm.h"
10: #include "../h/dir.h"
11: #include "../h/user.h"
12: #include "../h/tty.h"
13: #include "../h/proc.h"
14: #include "../h/mx.h"
15: #include "../h/inode.h"
16: #include "../h/file.h"
17: #include "../h/reg.h"
18: #include "../h/conf.h"
19: #include "../h/buf.h"
20: #include "../h/dk.h"
21:
22: char partab[];
23:
24: /*
25: * When running dz's using only SAE (silo alarm) on input
26: * it is necessary to call dzrint() at clock interrupt time.
27: * This is unsafe unless spl5()s in tty code are changed to
28: * spl6()s to block clock interrupts. Note that the dh driver
29: * currently in use works the same way as the dz, even though
30: * we could try to more intelligently manage its silo.
31: * Thus don't take this out if you have no dz's unless you
32: * change clock.c and dhtimer().
33: */
34: #define spl5 spl6
35:
36: /*
37: * Input mapping table-- if an entry is non-zero, when the
38: * corresponding character is typed preceded by "\" the escape
39: * sequence is replaced by the table value. Mostly used for
40: * upper-case only terminals.
41: */
42:
43: char maptab[]; /* see tty.c */
44:
45: /*
46: * shorthand
47: */
48: #define q1 tp->t_rawq
49: #define q2 tp->t_canq
50: #define q3 tp->t_outq
51: #define q4 tp->t_un.t_ctlq
52:
53: #define OBUFSIZ 100
54:
55: /*
56: * routine called on opens while tp->t_line == NTTYDISC
57: * establishes a process group for distribution of
58: * quits and interrupts from the tty.
59: * (actually, pp->p_pgrp can't be 0 when this routine
60: * is called since NTTYDISC is not the default discipline)
61: */
62: ntyopen(dev, tp)
63: dev_t dev;
64: register struct tty *tp;
65: {
66: register struct proc *pp;
67:
68: pp = u.u_procp;
69: tp->t_dev = dev;
70: if(pp->p_pgrp == 0) {
71: u.u_ttyp = tp;
72: u.u_ttyd = dev;
73: if (tp->t_pgrp == 0)
74: tp->t_pgrp = pp->p_pid;
75: pp->p_pgrp = tp->t_pgrp;
76: }
77: tp->t_state &= ~WOPEN;
78: tp->t_state |= ISOPEN;
79: if (tp->t_line != NTTYDISC)
80: wflushtty(tp);
81: }
82:
83: /*
84: * clean tp on last close
85: */
86: ntyclose(tp)
87: register struct tty *tp;
88: {
89:
90: wflushtty(tp);
91: /* let ttyclose do the work if we are really closing */
92: }
93:
94: /*
95: * block transfer input handler.
96: */
97: ntyrend(tp, pb, pe)
98: register struct tty *tp;
99: register char *pb, *pe;
100: {
101: int tandem;
102:
103: tandem = tp->t_flags&TANDEM;
104: if (tp->t_flags&RAW) {
105: (void) b_to_q(pb, pe-pb, &tp->t_rawq);
106: if (tp->t_chan)
107: (void) sdata(tp->t_chan);
108: else
109: wakeup((caddr_t)&tp->t_rawq);
110: } else {
111: tp->t_flags &= ~TANDEM;
112: while (pb < pe)
113: ntyinput(*pb++, tp);
114: tp->t_flags |= tandem;
115: }
116: if (tandem)
117: ttyblock(tp);
118: }
119:
120: /*
121: * reinput pending characters after state switch
122: * call at spl5().
123: */
124: ntypend(tp)
125: register struct tty *tp;
126: {
127: struct clist tq;
128: register c;
129:
130: tp->t_local &= ~LPENDIN;
131: tp->t_lstate |= LSTYPEN;
132: tq = tp->t_rawq;
133: tp->t_rawq.c_cc = 0;
134: tp->t_rawq.c_cf = tp->t_rawq.c_cl = 0;
135: while ((c = getc(&tq)) >= 0)
136: ntyinput(c, tp);
137: tp->t_lstate &= ~LSTYPEN;
138: }
139:
140: /*
141: * Place a character on raw TTY input queue, putting in delimiters
142: * and waking up top half as needed.
143: * Also echo if required.
144: * The arguments are the character and the appropriate
145: * tty structure.
146: */
147: ntyinput(c, tp)
148: register c;
149: register struct tty *tp;
150: {
151: register int t_flags;
152: int i;
153:
154: if (tp->t_local&LPENDIN)
155: ntypend(tp);
156: tk_nin++;
157: c &= 0377;
158: t_flags = tp->t_flags;
159: if (t_flags&TANDEM)
160: ttyblock(tp);
161: if ((t_flags&RAW)==0) {
162: if ((tp->t_lstate&LSTYPEN) == 0)
163: c &= 0177;
164: /* check for literal nexting very first */
165: if (tp->t_lstate&LSLNCH) {
166: c |= 0200;
167: tp->t_lstate &= ~LSLNCH;
168: }
169: if (c==tlun.t_lnextc) {
170: if (tp->t_flags&ECHO)
171: ntyout("^\b", tp);
172: tp->t_lstate |= LSLNCH;
173: /* check for output control functions */
174: } else if (c==tun.t_stopc) {
175: if ((tp->t_state&TTSTOP)==0) {
176: tp->t_state |= TTSTOP;
177: (*cdevsw[major(tp->t_dev)].d_stop)(tp);
178: return;
179: }
180: if (c!=tun.t_startc)
181: return;
182: } else if (c==tun.t_startc)
183: ;
184: /* check for input interrupts (and flushed output) */
185: else if (c==tlun.t_flushc) {
186: if (tp->t_local & LFLUSHO)
187: tp->t_local &= ~LFLUSHO;
188: else {
189: flushtty(tp, FWRITE);
190: ntyecho(c, tp);
191: if (tp->t_rawq.c_cc+tp->t_canq.c_cc)
192: ntyretype(tp);
193: tp->t_local |= LFLUSHO;
194: }
195: ttstart(tp);
196: return;
197: } else if (c==tlun.t_suspc || c==tun.t_intrc ||
198: c==tun.t_quitc) {
199: flushtty(tp, c==tlun.t_suspc ? FREAD : FREAD|FWRITE);
200: ntyecho(c, tp);
201: c = c==tun.t_intrc ? SIGINT :
202: ((c==tun.t_quitc) ? SIGQUIT : SIGTSTP);
203: if (tp->t_chan)
204: scontrol(tp->t_chan, M_SIG, c);
205: else
206: gsignal(tp->t_pgrp, c);
207: /* check for buffer editing functions - cooked mode */
208: } else if ((t_flags&CBREAK) == 0) {
209: if ((tp->t_lstate&LSQUOT) &&
210: (c==tp->t_erase||c==tp->t_kill)) {
211: ntyrub(unputc(&tp->t_rawq), tp);
212: c |= 0200;
213: }
214: if (c==tp->t_erase) {
215: if (tp->t_rawq.c_cc)
216: ntyrub(unputc(&tp->t_rawq), tp);
217: } else if (c==tp->t_kill) {
218: if (tp->t_local&LCRTKIL &&
219: tp->t_rawq.c_cc == tp->t_rocount) {
220: while (tp->t_rawq.c_cc)
221: ntyrub(unputc(&tp->t_rawq), tp);
222: } else {
223: ntyecho(c, tp);
224: ntyecho('\n', tp);
225: while (getc(&tp->t_rawq) > 0)
226: ;
227: tp->t_rocount = 0;
228: }
229: tp->t_lstate = 0;
230: } else if (c==tlun.t_werasc) {
231: if (tp->t_rawq.c_cc == 0)
232: goto out;
233: do {
234: c = unputc(&tp->t_rawq);
235: if (c != ' ' && c != '\t')
236: goto erasenb;
237: ntyrub(c, tp);
238: } while (tp->t_rawq.c_cc);
239: goto out;
240: erasenb:
241: do {
242: ntyrub(c, tp);
243: if (tp->t_rawq.c_cc == 0)
244: goto out;
245: c = unputc(&tp->t_rawq);
246: } while (c != ' ' && c != '\t');
247: (void) putc(c, &tp->t_rawq);
248: } else if (c==tlun.t_rprntc) {
249: ntyretype(tp);
250: /* check for cooked mode input buffer overflow */
251: } else if (tp->t_rawq.c_cc + tp->t_canq.c_cc > TTYHOG) {
252: /* we should start a timeout that flushes the
253: buffer if it stays full - same in CBREAK */
254: if (tp->t_outq.c_cc < TTHIWAT(tp))
255: (void) ntyoutput(CTRL(g), tp);
256: /* put data char in q for user and wakeup if a break char */
257: } else if (putc(c, &tp->t_rawq) >= 0) {
258: if (!ntbreakc(c, tp)) {
259: if (tp->t_rocount++ == 0)
260: tp->t_rocol = tp->t_col;
261: } else {
262: tp->t_rocount = 0;
263: catq(&tp->t_rawq, &tp->t_canq);
264: if (tp->t_chan)
265: (void) sdata(tp->t_chan);
266: else
267: wakeup((caddr_t)&tp->t_rawq);
268: if (tp->t_local&LINTRUP)
269: gsignal(tp->t_pgrp, SIGTINT);
270: }
271: tp->t_lstate &= ~LSQUOT;
272: if (c == '\\')
273: tp->t_lstate |= LSQUOT;
274: if (tp->t_lstate&LSERASE) {
275: tp->t_lstate &= ~LSERASE;
276: (void) ntyoutput('/', tp);
277: }
278: i = tp->t_col;
279: ntyecho(c, tp);
280: if (c==tun.t_eofc && tp->t_flags&ECHO) {
281: i = MIN(2, tp->t_col - i);
282: while (i > 0) {
283: (void) ntyoutput('\b', tp);
284: i--;
285: }
286: }
287: }
288: /* CBREAK mode */
289: } else if (tp->t_rawq.c_cc > TTYHOG) {
290: if (tp->t_outq.c_cc < TTHIWAT(tp))
291: (void) ntyoutput(CTRL(g), tp);
292: } else if (putc(c, &tp->t_rawq) >= 0) {
293: if (tp->t_local&LINTRUP)
294: gsignal(tp->t_pgrp, SIGTINT);
295: if (tp->t_chan)
296: (void) sdata(tp->t_chan);
297: else
298: wakeup((caddr_t)&tp->t_rawq);
299: ntyecho(c, tp);
300: }
301: /* RAW mode */
302: } else if (tp->t_rawq.c_cc > TTYHOG)
303: flushtty(tp, FREAD|FWRITE);
304: else if (putc(c, &tp->t_rawq) >= 0) {
305: if (tp->t_local&LINTRUP)
306: gsignal(tp->t_pgrp, SIGTINT);
307: if (tp->t_chan)
308: (void) sdata(tp->t_chan);
309: else
310: wakeup((caddr_t)&tp->t_rawq);
311: }
312: out:
313: tp->t_state &= ~TTSTOP;
314: tp->t_local &= ~LFLUSHO;
315: ttstart(tp);
316: }
317:
318: /*
319: * put character on TTY output queue, adding delays,
320: * expanding tabs, and handling the CR/NL bit.
321: * It is called both from the top half for output, and from
322: * interrupt level for echoing.
323: * The arguments are the character and the tty structure.
324: * Returns < 0 if putc succeeds, otherwise returns char to resend
325: * Must be recursive.
326: */
327: ntyoutput(c, tp)
328: register c;
329: register struct tty *tp;
330: {
331: register char *colp;
332: register ctype;
333:
334: if (tp->t_flags&RAW || tp->t_local&LLITOUT) {
335: if (tp->t_local&LFLUSHO)
336: return (-1);
337: if (putc(c, &tp->t_outq))
338: return(c);
339: tk_nout++;
340: return (-1);
341: }
342: /*
343: * Ignore EOT in normal mode to avoid hanging up
344: * certain terminals.
345: */
346: c &= 0177;
347: if (c==CEOT && (tp->t_flags&CBREAK)==0)
348: return (-1);
349: /*
350: * Turn tabs to spaces as required
351: */
352: if (c=='\t' && (tp->t_flags&TBDELAY)==XTABS) {
353: register int s;
354:
355: c = 8 - (tp->t_col&7);
356: if ((tp->t_local&LFLUSHO) == 0) {
357: s = spl5(); /* don't interrupt tabs */
358: c -= b_to_q(" ", c, &tp->t_outq);
359: tk_nout += c;
360: splx(s);
361: }
362: tp->t_col += c;
363: return (c ? -1 : '\t');
364: }
365: tk_nout++;
366: /*
367: * for upper-case-only terminals,
368: * generate escapes.
369: */
370: if (tp->t_flags&LCASE) {
371: colp = "({)}!|^~'`";
372: while(*colp++)
373: if(c == *colp++) {
374: if (ntyoutput('\\', tp) >= 0)
375: return (c);
376: c = colp[-2];
377: break;
378: }
379: if ('A'<=c && c<='Z') {
380: if (ntyoutput('\\', tp) >= 0)
381: return (c);
382: } else if ('a'<=c && c<='z')
383: c += 'A' - 'a';
384: }
385: /*
386: * turn <nl> to <cr><lf> if desired.
387: */
388: if (c=='\n' && tp->t_flags&CRMOD)
389: if (ntyoutput('\r', tp) >= 0)
390: return (c);
391: if (c=='~' && tp->t_local<ILDE)
392: c = '`';
393: if ((tp->t_local&LFLUSHO) == 0 && putc(c, &tp->t_outq))
394: return (c);
395: /*
396: * Calculate delays.
397: * The numbers here represent clock ticks
398: * and are not necessarily optimal for all terminals.
399: * The delays are indicated by characters above 0200.
400: * In raw mode there are no delays and the
401: * transmission path is 8 bits wide.
402: */
403: colp = &tp->t_col;
404: ctype = partab[c];
405: c = 0;
406: switch (ctype&077) {
407:
408: case ORDINARY:
409: (*colp)++;
410:
411: case CONTROL:
412: break;
413:
414: case BACKSPACE:
415: if (*colp)
416: (*colp)--;
417: break;
418:
419: case NEWLINE:
420: ctype = (tp->t_flags >> 8) & 03;
421: if(ctype == 1) { /* tty 37 */
422: if (*colp)
423: c = max(((unsigned)*colp>>4) + 3, (unsigned)6);
424: } else
425: if(ctype == 2) { /* vt05 */
426: c = 6;
427: }
428: *colp = 0;
429: break;
430:
431: case TAB:
432: ctype = (tp->t_flags >> 10) & 03;
433: if(ctype == 1) { /* tty 37 */
434: c = 1 - (*colp | ~07);
435: if(c < 5)
436: c = 0;
437: }
438: *colp |= 07;
439: (*colp)++;
440: break;
441:
442: case VTAB:
443: if(tp->t_flags & VTDELAY) /* tty 37 */
444: c = 0177;
445: break;
446:
447: case RETURN:
448: ctype = (tp->t_flags >> 12) & 03;
449: if(ctype == 1) { /* tn 300 */
450: c = 5;
451: } else if(ctype == 2) { /* ti 700 */
452: c = 10;
453: } else if(ctype == 3) { /* concept 100 */
454: int i;
455: if ((i = *colp) >= 0)
456: for (; i<9; i++)
457: (void) putc(0177, &tp->t_outq);
458: }
459: *colp = 0;
460: }
461: if(c && (tp->t_local&LFLUSHO) == 0)
462: (void) putc(c|0200, &tp->t_outq);
463: return (-1);
464: }
465:
466: /*
467: * Called from device's read routine after it has
468: * calculated the tty-structure given as argument.
469: */
470: ntread(tp)
471: register struct tty *tp;
472: {
473: register struct clist *qp;
474: register c, first;
475:
476: if ((tp->t_state&CARR_ON)==0)
477: return(0);
478: loop:
479: (void) spl5();
480: if (tp->t_local&LPENDIN)
481: ntypend(tp);
482: (void) spl0();
483: while (tp == u.u_ttyp && u.u_procp->p_pgrp != tp->t_pgrp) {
484: if (u.u_signal[SIGTTIN] == SIG_IGN ||
485: u.u_signal[SIGTTIN] == SIG_HOLD ||
486: (u.u_procp->p_flag&SDETACH) ||
487: u.u_procp->p_flag&SVFORK)
488: return (0);
489: gsignal(u.u_procp->p_pgrp, SIGTTIN);
490: sleep((caddr_t)&lbolt, TTIPRI);
491: }
492: if (tp->t_flags&RAW) {
493: (void) spl5();
494: if (tp->t_rawq.c_cc <= 0) {
495: if ((tp->t_state&CARR_ON)==0 || tp->t_chan!=NULL) {
496: (void) spl0();
497: return (0);
498: }
499: if (tp->t_local&LINTRUP &&
500: u.u_signal[SIGTINT] != SIG_DFL) {
501: u.u_error = EIO;
502: (void) spl0();
503: return (0);
504: }
505: sleep((caddr_t)&tp->t_rawq, TTIPRI);
506: (void) spl0();
507: goto loop;
508: }
509: (void) spl0();
510: while (tp->t_rawq.c_cc && passc(getc(&tp->t_rawq))>=0)
511: ;
512: return (0);
513: } else {
514: qp = tp->t_flags & CBREAK ? &tp->t_rawq : &tp->t_canq;
515: (void) spl5();
516: if (qp->c_cc <= 0) {
517: if ((tp->t_state&CARR_ON)==0 || tp->t_chan!=NULL) {
518: (void) spl0();
519: return (0);
520: }
521: if (tp->t_local&LINTRUP &&
522: u.u_signal[SIGTINT] != SIG_DFL) {
523: u.u_error = EIO;
524: (void) spl0();
525: return (0);
526: }
527: sleep((caddr_t)&tp->t_rawq, TTIPRI);
528: (void) spl0();
529: goto loop;
530: }
531: (void) spl0();
532: first = 1;
533: while ((c = getc(qp)) >= 0) {
534: if (tp->t_flags&CRMOD && c == '\r')
535: c = '\n';
536: if (tp->t_flags&LCASE && c <= 0177)
537: if (tp->t_lstate&LSBKSL) {
538: if (maptab[c])
539: c = maptab[c];
540: tp->t_lstate &= ~LSBKSL;
541: } else if (c >= 'A' && c <= 'Z')
542: c += 'a' - 'A';
543: else if (c == '\\') {
544: tp->t_lstate |= LSBKSL;
545: continue;
546: }
547: if (c == tlun.t_dsuspc) {
548: gsignal(tp->t_pgrp, SIGTSTP);
549: if (first) {
550: sleep((caddr_t)&lbolt, TTIPRI);
551: goto loop;
552: }
553: break;
554: }
555: if (c == tun.t_eofc && (tp->t_flags&CBREAK)==0)
556: break;
557: if (passc(c & 0177) < 0)
558: break;
559: if ((tp->t_flags&CBREAK)==0 && ntbreakc(c, tp))
560: break;
561: first = 0;
562: }
563: tp->t_lstate &= ~LSBKSL;
564: }
565:
566: if (tp->t_state&TBLOCK && tp->t_rawq.c_cc < TTYHOG/5) {
567: if (putc(tun.t_startc, &tp->t_outq)==0) {
568: tp->t_state &= ~TBLOCK;
569: ttstart(tp);
570: }
571: tp->t_char = 0;
572: }
573:
574: return (tp->t_rawq.c_cc + tp->t_canq.c_cc);
575: }
576:
577: /*
578: * Called from the device's write routine after it has
579: * calculated the tty-structure given as argument.
580: */
581: caddr_t
582: ntwrite(tp)
583: register struct tty *tp;
584: {
585: #ifdef VAX
586: /*
587: * THE POSITIONING OF CP, CC, AND CE ARE CRITICAL
588: * AND MUST NOT BE CHANGED WITHOUT PATCHING
589: * THE 'ASM' INLINES BELOW. WATCH OUT.
590: */
591: #endif
592: register char *cp;
593: register int cc, ce;
594: register i;
595: char obuf[OBUFSIZ];
596: register c;
597: int hiwat = TTHIWAT(tp);
598:
599: if ((tp->t_state&CARR_ON)==0)
600: return (NULL);
601: loop:
602: while (u.u_procp->p_pgrp != tp->t_pgrp && tp == u.u_ttyp &&
603: (tp->t_local<OSTOP) && (u.u_procp->p_flag&SVFORK)==0 &&
604: u.u_signal[SIGTTOU] != SIG_IGN &&
605: u.u_signal[SIGTTOU] != SIG_HOLD &&
606: (u.u_procp->p_flag&SDETACH)==0) {
607: gsignal(u.u_procp->p_pgrp, SIGTTOU);
608: sleep((caddr_t)&lbolt, TTIPRI);
609: }
610: while (u.u_count) {
611: cc = MIN(u.u_count, OBUFSIZ);
612: cp = obuf;
613: iomove(cp, (unsigned)cc, B_WRITE);
614: if (u.u_error)
615: break;
616: if (tp->t_outq.c_cc > hiwat)
617: goto ovhiwat;
618: if (tp->t_local&LFLUSHO)
619: continue;
620: if (tp->t_flags&LCASE || tp->t_local<ILDE) {
621: while (cc--) {
622: c = *cp++;
623: tp->t_rocount = 0;
624: while((c = ntyoutput(c, tp)) >= 0) {
625: /* out of clists, wait a bit */
626: ttstart(tp);
627: sleep((caddr_t)&lbolt, TTOPRI);
628: tp->t_rocount = 0;
629: }
630: if (tp->t_outq.c_cc > hiwat)
631: goto ovhiwat;
632: }
633: continue;
634: }
635: while (cc) {
636: if (tp->t_flags&RAW || tp->t_local&LLITOUT)
637: ce = cc;
638: else {
639: #ifdef VAX
640: asm(" scanc r9,(r10),_partab,$077");
641: asm(" subl3 r0,r9,r8");
642: #else
643: ce=0;
644: while(((partab[*(unsigned char *)(cp+ce)]&077)==0)&&(ce<cc))
645: ce++;
646: #endif
647: if (ce==0) {
648: tp->t_rocount = 0;
649: if (ntyoutput(*cp, tp) >= 0) {
650: ttstart(tp);
651: sleep((caddr_t)&lbolt, TTOPRI);
652: continue;
653: }
654: cp++;
655: cc--;
656: if (tp->t_outq.c_cc > hiwat)
657: goto ovhiwat;
658: }
659: }
660: tp->t_rocount = 0;
661: i=b_to_q(cp,ce,&tp->t_outq);
662: ce-=i;
663: tk_nout+=ce;
664: tp->t_col+=ce;
665: cp+=ce;
666: cc-=ce;
667: if (i) {
668: ttstart(tp);
669: sleep((caddr_t)&lbolt, TTOPRI);
670: }
671: if (ce || tp->t_outq.c_cc > hiwat)
672: goto ovhiwat;
673: }
674: }
675: ttstart(tp);
676: return(NULL);
677:
678: ovhiwat:
679: (void) spl5();
680: u.u_base -= cc;
681: u.u_offset -= cc;
682: u.u_count += cc;
683: if (tp->t_outq.c_cc <= hiwat) {
684: (void) spl0();
685: goto loop;
686: }
687: ttstart(tp);
688: tp->t_state |= ASLEEP;
689: if (tp->t_chan) {
690: (void) spl0();
691: return ((caddr_t)&tp->t_outq);
692: }
693: sleep((caddr_t)&tp->t_outq, TTOPRI);
694: (void) spl0();
695: goto loop;
696: }
697:
698: /*
699: * Rubout one character from the rawq of tp
700: * as cleanly as possible.
701: */
702: ntyrub(c, tp)
703: register c;
704: register struct tty *tp;
705: {
706: register char *cp;
707: register int savecol;
708: int s;
709: char *nextc();
710:
711: if ((tp->t_flags&ECHO)==0)
712: return;
713: tp->t_local &= ~LFLUSHO;
714: c &= 0377;
715: if (tp->t_local&LCRTBS) {
716: if (tp->t_rocount == 0) {
717: /*
718: * Screwed by ttwrite; retype
719: */
720: ntyretype(tp);
721: return;
722: }
723: if (c==('\t'|0200) || c==('\n'|0200))
724: ntyrubo(tp, 2);
725: else switch(partab[c&=0177] & 0177) {
726:
727: case ORDINARY:
728: if (tp->t_flags&LCASE && c >= 'A' && c <= 'Z')
729: ntyrubo(tp, 2);
730: else
731: ntyrubo(tp, 1);
732: break;
733:
734: case VTAB:
735: case BACKSPACE:
736: case CONTROL:
737: case RETURN:
738: if (tp->t_local & LCTLECH)
739: ntyrubo(tp, 2);
740: break;
741:
742: case TAB:
743: if (tp->t_rocount < tp->t_rawq.c_cc) {
744: ntyretype(tp);
745: return;
746: }
747: s = spl5();
748: savecol = tp->t_col;
749: tp->t_lstate |= LSCNTTB;
750: tp->t_local |= LFLUSHO;
751: tp->t_col = tp->t_rocol;
752: for (cp = tp->t_rawq.c_cf; cp; cp = nextc(&tp->t_rawq, cp))
753: ntyecho(*cp, tp);
754: tp->t_local &= ~LFLUSHO;
755: tp->t_lstate &= ~LSCNTTB;
756: splx(s);
757: /*
758: * savecol will now be length of the tab
759: */
760: savecol -= tp->t_col;
761: tp->t_col += savecol;
762: if (savecol > 8)
763: savecol = 8; /* overflow screw */
764: while (--savecol >= 0)
765: (void) ntyoutput('\b', tp);
766: break;
767:
768: default:
769: panic("ttyrub");
770: }
771: } else if (tp->t_local&LPRTERA) {
772: if ((tp->t_lstate&LSERASE) == 0) {
773: (void) ntyoutput('\\', tp);
774: tp->t_lstate |= LSERASE;
775: }
776: ntyecho(c, tp);
777: } else
778: ntyecho(tp->t_erase, tp);
779: tp->t_rocount--;
780: }
781:
782: /*
783: * Crt back over cnt chars perhaps
784: * erasing them.
785: */
786: ntyrubo(tp, cnt)
787: register struct tty *tp;
788: int cnt;
789: {
790:
791: while (--cnt >= 0)
792: ntyout(tp->t_local&LCRTERA ? "\b \b" : "\b", tp);
793: }
794:
795: /*
796: * Reprint the rawq line.
797: * We assume c_cc has already been checked.
798: */
799: ntyretype(tp)
800: register struct tty *tp;
801: {
802: register char *cp;
803: char *nextc();
804: int s;
805:
806: if (tlun.t_rprntc != 0377)
807: ntyecho(tlun.t_rprntc, tp);
808: (void) ntyoutput('\n', tp);
809: s = spl5();
810: for (cp = tp->t_canq.c_cf; cp; cp = nextc(&tp->t_canq, cp))
811: ntyecho(*cp, tp);
812: for (cp = tp->t_rawq.c_cf; cp; cp = nextc(&tp->t_rawq, cp))
813: ntyecho(*cp, tp);
814: tp->t_lstate &= ~LSERASE;
815: splx(s);
816: tp->t_rocount = tp->t_rawq.c_cc;
817: tp->t_rocol = 0;
818: }
819:
820: /*
821: * Echo a typed character to the terminal
822: */
823: ntyecho(c, tp)
824: register c;
825: register struct tty *tp;
826: {
827:
828: if ((tp->t_lstate & LSCNTTB) == 0)
829: tp->t_local &= ~LFLUSHO;
830: c &= 0377;
831: if (tp->t_flags&ECHO) {
832: if (c == '\r' && tp->t_flags&CRMOD)
833: c = '\n';
834: if (tp->t_local&LCTLECH) {
835: if ((c&0177) <= 037 && c!='\t' && c!='\n' || (c&0177)==0177) {
836: (void) ntyoutput('^', tp);
837: c &= 0177;
838: if (c == 0177)
839: c = '?';
840: else if (tp->t_flags&LCASE)
841: c += 'a' - 1;
842: else
843: c += 'A' - 1;
844: }
845: }
846: (void) ntyoutput(c & 0177, tp);
847: }
848: }
849:
850: /*
851: * Is c a break char for tp?
852: */
853: ntbreakc(c, tp)
854: register c;
855: register struct tty *tp;
856: {
857: return (c == '\n' || c == tun.t_eofc || c == tun.t_brkc ||
858: c == '\r' && (tp->t_flags&CRMOD));
859: }
860:
861: /*
862: * send string cp to tp
863: */
864: ntyout(cp, tp)
865: register char *cp;
866: register struct tty *tp;
867: {
868: register char c;
869:
870: while (c = *cp++)
871: (void) ntyoutput(c, tp);
872: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.