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