![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nttyld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / io|
Return to nttyld.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 root 1: #include "sys/param.h"
2: #include "sys/stream.h"
3: #include "sys/ttyio.h"
4: #include "sys/nttyio.h"
5: #include "sys/ttyld.h"
6: #include "sys/nttyld.h"
7: #include "sys/conf.h"
8: #include "sys/file.h"
9:
10: extern char maptab[], /* see dev/ttyld.c */
11: partab[]; /* see sys/partab.c */
12:
13:
14: extern struct nttyld ntty[];
15: extern int nttycnt;
16:
17: int ntclose(), /* queue close routine */
18: ntin(), /* reader queue put routine */
19: ntinsrv(), /* reader queue service routine */
20: ntout(), /* writer queue put routine */
21: ntoutsrv(); /* writer queue service routine */
22: long ntopen(); /* queue open routine */
23:
24: static struct qinit rinit = { ntin, ntinsrv, ntopen, ntclose, 300, 0 },
25: winit = { ntout, ntoutsrv, ntopen, ntclose, 300, 200 };
26: struct streamtab nttystream = { &rinit, &winit };
27:
28: #define CANBSIZ 256 /* why not NT_NIN? */
29:
30: /*
31: * Backspace over "n" characters, perhaps erasing them.
32: * Called from ntrubout().
33: */
34:
35: ntbs (nt, n)
36: register struct nttyld *nt;
37: register int n;
38: {
39: while (--n >= 0)
40: if (putd (putq, nt->nt_outq, '\b')) {
41: nt->nt_state |= NT_ECHO;
42: if (nt->nt_local & LCRTERA) {
43: (void) putd (putq, nt->nt_outq, ' ');
44: (void) putd (putq, nt->nt_outq, '\b');
45: }
46: }
47: return;
48: }
49:
50:
51: /*
52: * Set default control characters.
53: * Called by ntopen().
54: */
55:
56: ntchars (nt)
57: register struct nttyld *nt;
58: {
59: static struct tchars tchars = { CINTR, CQUIT, CSTART, CSTOP, CEOT,
60: 0377 };
61: static struct ltchars ltchars = { CSUSP, CDSUSP, CRPRNT, CFLUSH,
62: CWERAS, CLNEXT };
63:
64: nt->nt_erase = CERASE;
65: nt->nt_kill = CKILL;
66: nt->nt_tchr = tchars;
67: nt->nt_ltchr = ltchars;
68: return;
69: }
70:
71:
72: ntclose (q)
73: register struct queue *q;
74: {
75: register struct nttyld *nt = (struct nttyld *) q->ptr;
76:
77: nt->nt_state = 0;
78: return;
79: }
80:
81:
82: /*
83: * Put input buffer on read queue followed by a delimiter.
84: * Called from ntinc() when a line break character is read,
85: * and from ntioctl() when switching from cooked to raw or cbreak mode.
86: */
87:
88: ntcooked (nt)
89: register struct nttyld *nt;
90: {
91: register char *s, *t;
92: register struct block *b;
93: register struct queue *q = RD (nt->nt_outq);
94:
95: if (!(q->flag & QFULL) && (b = allocb (1))) {
96: for (t = (s = nt->nt_in) + nt->nt_nin; s < t; s++)
97: (void) putd (putq, q, *s);
98: b->class |= S_DELIM;
99: putq (q, b);
100: nt->nt_delct++;
101: }
102: qenable (q);
103: nt->nt_nin = 0;
104: nt->nt_trash = 0;
105: return;
106: }
107:
108:
109: /*
110: * Echo a typed character to a terminal.
111: */
112:
113: ntecho (c, nt)
114: register int c;
115: register struct nttyld *nt;
116: {
117: register struct queue *echoq = nt->nt_outq;
118:
119: nt->nt_local &= ~LFLUSHO;
120: if (!(nt->nt_flags & ECHO) || echoq->flag & QFULL)
121: return;
122: c &= 0377;
123: if (nt->nt_flags & RAW)
124: goto out;
125: if (c == '\r' && nt->nt_flags & CRMOD)
126: c = '\n';
127: if (c != '\n' && c != '\t' && nt->nt_local & LCTLECH)
128: if ((c &= 0177) <= 037 || c == 0177) {
129: (void) putd (putq, echoq, '^');
130: if (c == 0177)
131: c = '?';
132: else if (nt->nt_flags & LCASE)
133: c += 'a' - 1;
134: else c += 'A' - 1;
135: goto out;
136: }
137:
138: if ((c &= 0177) == CEOT) /* terminals don't like it */
139: return;
140:
141: out:
142: if (putd (putq, echoq, c))
143: nt->nt_state |= NT_ECHO;
144: return;
145: }
146:
147:
148: /*
149: * Flush all input and/or all output tty queues.
150: */
151:
152: ntflush (nt, rw)
153: struct nttyld *nt;
154: int rw;
155: {
156: struct queue *wrq = nt->nt_outq,
157: *rdq = RD (wrq);
158:
159: if (rw & FREAD) {
160: flushq (rdq, 0);
161: (void) putctl (rdq->next, M_FLUSH);
162: nt->nt_delct = 0;
163: nt->nt_nin = 0;
164: nt->nt_trash = 0;
165: nt->nt_lstate = 0;
166: }
167: if (rw & FWRITE) {
168: flushq (wrq, 0);
169: (void) putctl (wrq->next, M_FLUSH);
170: }
171: return;
172: }
173:
174:
175: /*
176: * Reader queue (input from tty) put routine.
177: */
178:
179: ntin (q, b)
180: struct queue *q;
181: register struct block *b;
182: {
183: register struct nttyld *nt = (struct nttyld *) q->ptr;
184:
185: switch (b->type) {
186: case M_DATA:
187: if (nt->nt_flags & RAW && !(nt->nt_flags & ECHO))
188: break;
189: nt->nt_state &= ~NT_ECHO;
190: while (b->rptr < b->wptr)
191: ntinc ((int) *b->rptr++, nt);
192: freeb (b);
193: if (nt->nt_state & NT_ECHO && nt->nt_outq->next->flag & QDELIM)
194: (void) qpctld (nt->nt_outq, M_DATA);
195: return;
196: case M_BREAK:
197: if (nt->nt_flags & RAW) { /* speed-change hack */
198: b->type = M_DATA;
199: if (b->wptr < b->lim)
200: *b->wptr++ = '\0';
201: break;
202: }
203: (void) putctl1 (q->next, M_SIGNAL, SIGINT);
204: ntflush (nt, FREAD | FWRITE);
205: freeb (b);
206: return;
207: case M_HANGUP:
208: (*q->next->qinfo->putp)(q->next, b);
209: return;
210: }
211:
212: if (q->next->flag & QFULL)
213: freeb (b);
214: else (*q->next->qinfo->putp)(q->next, b);
215: return;
216: }
217:
218:
219: /*
220: * Process a single input character.
221: * Called (at interrupt level) by ntin().
222: */
223:
224: ntinc (c, nt)
225: register c;
226: register struct nttyld *nt;
227: {
228: register int t_flags;
229:
230: c &= 0377;
231: t_flags = nt->nt_flags;
232:
233: if (t_flags & RAW) {
234: if (!(nt->nt_readq->next->flag & QFULL))
235: if (putd (nt->nt_readq->next->qinfo->putp, nt->nt_readq->next, c))
236: ntecho (c, nt);
237: return;
238: }
239:
240: if (!(nt->nt_lstate & LSTYPEN))
241: c &= 0177;
242:
243: /*
244: * Interpret literal-next-character control character (^V).
245: */
246: if (nt->nt_lstate & LSLNCH) {
247: c |= 0200;
248: nt->nt_lstate &= ~LSLNCH;
249: }
250: if (c == nt->nt_lnextc) {
251: nt->nt_lstate |= LSLNCH;
252: if (nt->nt_flags & ECHO)
253: if (putd (putq, nt->nt_outq, '^')) {
254: nt->nt_state |= NT_ECHO;
255: (void) putd (putq, nt->nt_outq, '\b');
256: }
257: return;
258: }
259:
260: if (ntstst (c, nt) || /* start, stop */
261: ntoflush (c, nt) || /* flush output */
262: ntsigc (c, nt)) /* interrupt/quit/stop */
263: return;
264:
265: if (c == '\r' && t_flags & CRMOD)
266: c = '\n';
267: if (t_flags & LCASE && c >= 'A' && c <= 'Z')
268: c += 'a' - 'A';
269:
270: if (t_flags & CBREAK) {
271: if (nt->nt_readq->next->flag & QFULL) {
272: if (putd (putq, nt->nt_outq, CTRL('g')))
273: nt->nt_state |= NT_ECHO;
274: }
275: #ifdef notdef
276: else if (c == nt->nt_dsuspc)
277: (void) putctl1 (nt->nt_readq->next, M_SSIGNAL, SIGTSTP);
278: #endif
279: else if (putd (nt->nt_readq->next->qinfo->putp, nt->nt_readq->next, c&0177))
280: ntecho (c, nt);
281: return;
282: }
283:
284: if (nt->nt_lstate & LSQUOT) {
285: nt->nt_lstate &= ~LSQUOT;
286: if (c == nt->nt_erase || c == nt->nt_kill) {
287: c |= 0200;
288: ntrubout (nt);
289: }
290: }
291: if (c == '\\')
292: nt->nt_lstate |= LSQUOT;
293:
294: if (c == nt->nt_erase)
295: ntrubout (nt); /* erase character */
296: else if (c == nt->nt_kill)
297: ntkill (nt); /* erase line */
298: else if (c == nt->nt_werasc)
299: ntwerase (nt); /* erase word */
300: else if (c == nt->nt_rprntc)
301: ntreprint (nt); /* reprint line */
302: else {
303: if (nt->nt_nin < NT_NIN) {
304: if (nt->nt_nin == 0)
305: nt->nt_rocol = nt->nt_col;
306: nt->nt_in[nt->nt_nin++] = c;
307: }
308: else {
309: if (putd (putq, nt->nt_outq, CTRL('g')))
310: nt->nt_state |= NT_ECHO;
311: return;
312: }
313:
314: if (c == '\n' || c == nt->nt_eofc || c == nt->nt_brkc ||
315: c == '\r' && (nt->nt_flags & CRMOD))
316: ntcooked (nt);
317:
318: if (nt->nt_lstate & LSERASE) {
319: nt->nt_lstate &= ~LSERASE;
320: if (putd (putq, nt->nt_outq, '/'))
321: nt->nt_state |= NT_ECHO;
322: }
323:
324: ntecho (c, nt);
325: if (c == nt->nt_eofc && nt->nt_flags & ECHO &&
326: nt->nt_local & LCTLECH)
327: if (putd (putq, nt->nt_outq, '\b')) {
328: nt->nt_state |= NT_ECHO;
329: (void) putd (putq, nt->nt_outq, '\b');
330: }
331: }
332: return;
333: }
334:
335:
336: /*
337: * Reader queue (tty input) service routine.
338: * Only cooked mode data and delimiters come through here, via ntcooked().
339: */
340:
341: ntinsrv (q)
342: register struct queue *q;
343: {
344: register struct nttyld *nt;
345: register struct block *b;
346: register char *op;
347: register int c;
348: static char canonb[CANBSIZ];
349:
350: if (q->next->flag & QFULL)
351: return;
352: nt = (struct nttyld *) q->ptr;
353: op = canonb;
354: while (nt->nt_delct) {
355: b = getq(q);
356: if (b == NULL) {
357: if (op > canonb)
358: putcpy (q->next, canonb, op - canonb);
359: return;
360: }
361: while (b->rptr < b->wptr) {
362: c = *b->rptr++;
363: if (c & 0200) { /* escaped */
364: c &= 0177;
365: if (nt->nt_flags & LCASE && maptab[c])
366: c = maptab[c];
367: else if (c != nt->nt_erase &&
368: c != nt->nt_kill && c != nt->nt_eofc)
369: *op++ = '\\';
370: }
371: else {
372: #ifdef notdef
373: /*
374: * Interpret delayed stop process
375: * control character (^Y).
376: */
377: if (c == nt->nt_dsuspc) {
378: putcpy (q->next, canonb, op - canonb);
379: op = canonb;
380: (void) putctl1 (q->next, M_SSIGNAL,
381: SIGTSTP);
382: continue;
383: }
384: #endif
385: if (c == nt->nt_eofc)
386: continue;
387: }
388: *op++ = c;
389: if (op >= &canonb[CANBSIZ-1]) {
390: putcpy (q->next, canonb, op - canonb);
391: op = canonb;
392: }
393: }
394: if ((b->class & S_DELIM) == 0)
395: freeb(b);
396: else { /* end of line */
397: if (op > canonb)
398: putcpy(q->next, canonb, op - canonb);
399: (*q->next->qinfo->putp)(q->next, b); /* empty S_DELIM */
400: nt->nt_delct--;
401: op = canonb;
402: }
403: }
404:
405: return;
406: }
407:
408:
409: /*
410: * Acknowledge ioctl message.
411: * Called by ntioctl().
412: */
413:
414: ntiocack (q, b, n)
415: register struct queue *q;
416: register struct block *b;
417: register int n;
418: {
419: if (n > 0)
420: n += sizeof (int); /* for ioctl command */
421: b->wptr = b->rptr + n;
422: b->type = M_IOCACK;
423: qreply (q, b);
424: return;
425: }
426:
427:
428: /*
429: * Terminal I/O control operations.
430: * Called by ntoutsrv().
431: */
432:
433: ntioctl (q, b)
434: register struct queue *q;
435: register struct block *b;
436: {
437: register struct nttyld *nt = (struct nttyld *) q->ptr;
438: register struct ntioc *ioc = (struct ntioc *) b->rptr;
439: int s;
440:
441: switch (ioc->command) {
442:
443: /*
444: * Set new parameters
445: */
446: case TIOCSETP:
447: case TIOCSETN:
448: s = spl6();
449: if (ioc->arg.sg.sg_flags & (RAW|CBREAK) &&
450: !(nt->nt_flags & (RAW|CBREAK))) {
451: /*
452: * Before leaving cooked mode, push through
453: * any characters that made it to ntin().
454: */
455: if (nt->nt_nin > 0)
456: ntcooked (nt);
457: ntinsrv (RD (nt->nt_outq));
458: }
459: nt->nt_erase = ioc->arg.sg.sg_erase;
460: nt->nt_kill = ioc->arg.sg.sg_kill;
461: nt->nt_flags = ioc->arg.sg.sg_flags;
462: nt->nt_readq->flag &= ~QDELIM;
463: if ((nt->nt_flags & (RAW|CBREAK))==0)
464: nt->nt_readq->flag |= QDELIM;
465: splx (s);
466:
467: ntiocack (q, b, 0);
468: break;
469:
470: /*
471: * Send current parameters to user
472: */
473: case TIOCGETP:
474: ioc->arg.sg.sg_erase = nt->nt_erase;
475: ioc->arg.sg.sg_kill = nt->nt_kill;
476: ioc->arg.sg.sg_flags = nt->nt_flags;
477: ioc->arg.sg.sg_ispeed =
478: ioc->arg.sg.sg_ospeed = B9600;
479:
480: b->wptr = b->rptr + sizeof (int) + sizeof (struct sgttyb);
481: b->wptr = 2 + b->rptr + sizeof (int) + sizeof (struct sgttyb);
482: ntiocack (q, b, sizeof (struct sgttyb));
483: break;
484:
485: /*
486: * Set/get special characters
487: */
488: case TIOCSETC:
489: nt->nt_tchr = ioc->arg.tchr;
490: ntiocack (q, b, 0);
491: break;
492:
493: case TIOCGETC:
494: ioc->arg.tchr = nt->nt_tchr;
495: ntiocack (q, b, sizeof (struct tchars));
496: break;
497:
498: /*
499: * Set/get local special characters.
500: */
501: case TIOCSLTC:
502: nt->nt_ltchr = ioc->arg.ltchr;
503: ntiocack (q, b, 0);
504: break;
505:
506: case TIOCGLTC:
507: ioc->arg.ltchr = nt->nt_ltchr;
508: ntiocack (q, b, sizeof (struct ltchars));
509: break;
510:
511: /*
512: * Modify local mode word.
513: */
514: case TIOCLBIS:
515: nt->nt_local |= ioc->arg.local;
516: ntiocack (q, b, 0);
517: break;
518:
519: case TIOCLBIC:
520: nt->nt_local &= ~ioc->arg.local;
521: ntiocack (q, b, 0);
522: break;
523:
524: case TIOCLSET:
525: nt->nt_local = ioc->arg.local;
526: ntiocack (q, b, 0);
527: break;
528:
529: case TIOCLGET:
530: ioc->arg.local = nt->nt_local;
531: ntiocack (q, b, sizeof (short));
532: break;
533:
534: /*
535: * Return number of characters in the output.
536: */
537: case TIOCOUTQ:
538:
539: default:
540: (*q->next->qinfo->putp)(q->next, b);
541: break;
542: }
543:
544: return;
545: }
546:
547:
548: /*
549: * Erase entire input buffer.
550: * Called by ntinc().
551: */
552:
553: ntkill (nt)
554: register struct nttyld *nt;
555: {
556: if (nt->nt_local & LCRTKIL && !nt->nt_trash) {
557: while (nt->nt_nin > 0)
558: ntrubout (nt);
559: }
560: else {
561: ntecho (nt->nt_kill, nt);
562: ntecho ('\n', nt);
563: nt->nt_nin = 0;
564: nt->nt_trash = 0;
565: }
566: nt->nt_lstate = 0;
567: return;
568: }
569:
570:
571: /*
572: * Interpret the flush-output (^O) control character.
573: * Called by ntinc().
574: */
575:
576: int
577: ntoflush (c, nt)
578: register int c;
579: register struct nttyld *nt;
580: {
581: if (nt->nt_local & LFLUSHO) {
582: nt->nt_local &= ~LFLUSHO;
583: if (c == nt->nt_flushc)
584: return (1);
585: }
586: else if (c == nt->nt_flushc) {
587: ntflush (nt, FWRITE);
588: ntecho (c, nt);
589: ntreprint (nt);
590: nt->nt_local |= LFLUSHO;
591: return (1);
592: }
593:
594: return (0);
595: }
596:
597:
598: /*ARGSUSED*/
599:
600: long
601: ntopen (q, dev)
602: register struct queue *q;
603: int dev;
604: {
605: register struct nttyld *nt;
606:
607: if (q->ptr)
608: return (1); /* already attached */
609:
610: for (nt = ntty; nt->nt_state & NT_USE; nt++)
611: if (nt >= &ntty[nttycnt-1])
612: return (0);
613:
614: WR (q)->ptr = q->ptr = (caddr_t) nt;
615: nt->nt_outq = WR (q);
616: nt->nt_readq = q;
617: nt->nt_nin = 0;
618: nt->nt_state = NT_USE;
619: nt->nt_flags = ECHO | CRMOD;
620: nt->nt_col = 0;
621: nt->nt_delct = 0;
622: ntchars (nt); /* set default control characters */
623: nt->nt_trash = 0;
624: nt->nt_local = 0;
625: nt->nt_lstate = 0;
626: q->flag |= QDELIM;
627: return (1);
628: }
629:
630:
631: /*
632: * Writer queue (output to tty) put routine.
633: */
634:
635: ntout (wrq, b)
636: register struct queue *wrq;
637: register struct block *b;
638: {
639: if (b->type == M_DATA)
640: b->type = M_CTL; /* see ntoutsrv() */
641: putq (wrq, b);
642: return;
643: }
644:
645:
646: /*
647: * Output a block of data to a terminal.
648: * Handle tab expansion, case conversion, turning CR to CRLF, delays, etc.
649: * Called from ntoutsrv().
650: */
651:
652: ntoutb (nt, ib)
653: register struct nttyld *nt;
654: register struct block *ib;
655: {
656: register struct block *ob = 0;
657: register struct queue *q = nt->nt_outq;
658: register int c, delay, ctype;
659: char *colp;
660:
661: while (ib->rptr < ib->wptr) {
662: if (!ob || ob->wptr >= ob->lim) {
663: if (ob) {
664: if (nt->nt_local & LFLUSHO)
665: break;
666: (*q->next->qinfo->putp)(q->next, ob);
667: }
668: if (q->next->flag & QFULL || !(ob = allocb (QBSIZE))) {
669: putbq (q, ib);
670: return;
671: }
672: }
673:
674: switch (c = *ib->rptr++ & 0177) {
675: case '\t':
676: if ((nt->nt_flags & TBDELAY) != XTABS)
677: break;
678:
679: /*
680: * Expand tabs to spaces.
681: */
682: for (;;) {
683: *ob->wptr++ = ' ';
684: nt->nt_col++;
685: if ((nt->nt_col & 07) == 0) /* every 8 */
686: break;
687: if (ob->wptr >= ob->lim) {
688: ib->rptr--;
689: break;
690: }
691: }
692: continue;
693: case '\n':
694: if (!(nt->nt_flags & CRMOD))
695: break;
696:
697: /*
698: * Turn <nl> to <cr><lf>.
699: */
700: if (nt->nt_state & NT_CR)
701: nt->nt_state &= ~NT_CR;
702: else {
703: nt->nt_state |= NT_CR;
704: c = '\r';
705: ib->rptr--;
706: }
707: break;
708: case '~':
709: if (nt->nt_local & LTILDE)
710: c = '`';
711: /* no break */
712: default:
713: if (!(nt->nt_flags & LCASE))
714: break;
715:
716: /*
717: * Generate escapes for upper-case-only terminals.
718: */
719: if (nt->nt_state & NT_CASE) {
720: nt->nt_state &= ~NT_CASE;
721: break;
722: }
723:
724: for (colp = "{(})|!~^`'"; *colp && c != *colp;
725: colp += 2);
726:
727: if (*colp || c >= 'A' && c <= 'Z') {
728: *--ib->rptr = *colp ? colp[1] : c;
729: nt->nt_state |= NT_CASE;
730: c = '\\';
731: }
732: else if (c >= 'a' && c <= 'z')
733: c += 'A' - 'a';
734: break;
735: }
736:
737: /*
738: * Store character.
739: */
740: *ob->wptr++ = c;
741:
742: /*
743: * Calculate delays and column movement.
744: * The delay values are in clock ticks and aren't
745: * necessarily optimal for all terminals.
746: */
747: delay = 0;
748:
749: switch (ctype = partab[c] & 077) {
750: case ORDINARY:
751: nt->nt_col++;
752: break;
753: case CONTROL:
754: break;
755: case BACKSPACE:
756: if (nt->nt_col)
757: nt->nt_col--;
758: break;
759: case NEWLINE:
760: ctype = (nt->nt_flags >> 8) & 03;
761: if (ctype == 1) { /* tty 37 */
762: if (nt->nt_col)
763: if ((delay = nt->nt_col >> 4) < 6)
764: delay = 6;
765: }
766: else if (ctype == 2) /* vt05 */
767: delay = 6;
768: if (!(nt->nt_flags & CRMOD))
769: nt->nt_col = 0;
770: break;
771: case TAB:
772: ctype = (nt->nt_flags >> 10) & 03;
773: if (ctype == 1) /* tty 37 */
774: if ((delay = 1 - (nt->nt_col | ~07)) < 5)
775: delay = 0;
776: nt->nt_col |= 07;
777: nt->nt_col++;
778: break;
779: case VTAB:
780: if (nt->nt_flags & VTDELAY)
781: delay = 127;
782: break;
783: case RETURN:
784: ctype = (nt->nt_flags >> 12) & 03;
785: if (ctype == 1) /* tn 300 */
786: delay = 5;
787: else if (ctype == 2) /* ti 700 */
788: delay = 10;
789: else if (ctype == 3) /* concept 100 */
790: if ((delay = 9 - nt->nt_col) < 0)
791: delay = 0;
792: nt->nt_col = 0;
793: break;
794: }
795:
796: if (delay) {
797: if (nt->nt_local & LFLUSHO)
798: break;
799: (*q->next->qinfo->putp)(q->next, ob);
800: if (ob = allocb(1)) {
801: ob->type = M_DELAY;
802: *ob->wptr++ = delay;
803: (*q->next->qinfo->putp)(q->next, ob);
804: }
805: ob = 0;
806: }
807: }
808:
809: if (ib->class & S_DELIM) {
810: if (ob == NULL)
811: ob = allocb(0);
812: if (ob)
813: ob->class |= S_DELIM;
814: }
815: freeb(ib);
816: if (ob) {
817: if (nt->nt_local & LFLUSHO)
818: freeb(ob);
819: else
820: (*q->next->qinfo->putp)(q->next, ob);
821: }
822: }
823:
824:
825: /*
826: * Writer queue (tty output) service routine.
827: * All tty output comes through here. Upstream data comes in M_CTL
828: * blocks via ntout(); echoed data comes in M_DATA blocks.
829: */
830:
831: ntoutsrv (q)
832: register struct queue *q;
833: {
834: register struct nttyld *nt = (struct nttyld *) q->ptr;
835: register struct block *b;
836:
837: while (b = getq (q))
838: switch (b->type) {
839: default:
840: freeb (b);
841: continue;
842: case M_BREAK:
843: if (q->next->flag & QFULL) {
844: putbq (q, b);
845: return;
846: }
847: (*q->next->qinfo->putp)(q->next, b);
848: continue;
849: case M_IOCTL:
850: if (q->next->flag & QFULL) {
851: putbq (q, b);
852: return;
853: }
854: ntioctl (q, b);
855: continue;
856: case M_FLUSH:
857: flushq (q, 0);
858: /* no break */
859: case M_IOCNAK:
860: case M_IOCACK:
861: (*q->next->qinfo->putp)(q->next, b);
862: continue;
863: case M_CTL:
864: case M_DATA:
865: if (nt->nt_local & LFLUSHO) {
866: freeb (b);
867: continue;
868: }
869: if (q->next->flag & QFULL) {
870: putbq (q, b);
871: return;
872: }
873: if (b->type == M_CTL) {
874: b->type = M_DATA;
875: nt->nt_trash = nt->nt_nin;
876: }
877: if (nt->nt_flags & RAW || nt->nt_local & LLITOUT) {
878: (*q->next->qinfo->putp)(q->next, b);
879: }
880: else ntoutb (nt, b);
881: continue;
882: }
883:
884: return;
885: }
886:
887:
888: /*
889: * Reprint input buffer.
890: */
891:
892: ntreprint (nt)
893: register struct nttyld *nt;
894: {
895: register char *in;
896: register int nin;
897:
898: if (nt->nt_rprntc != 0377)
899: ntecho ((int) nt->nt_rprntc, nt);
900: (void) putd (putq, nt->nt_outq, '\n');
901: for (in = nt->nt_in, nin = nt->nt_nin; nin > 0; in++, nin--)
902: ntecho (*in, nt);
903: nt->nt_lstate &= ~LSERASE;
904: nt->nt_trash = 0;
905: return;
906: }
907:
908:
909: /*
910: * Rubout the last character of the input buffer.
911: */
912:
913: ntrubout (nt)
914: register struct nttyld *nt;
915: {
916: register int c, cc, col, i;
917:
918: if (nt->nt_nin <= 0)
919: return;
920: c = nt->nt_in[--nt->nt_nin];
921:
922: if (!(nt->nt_flags & ECHO))
923: return;
924:
925: nt->nt_local &= ~LFLUSHO;
926:
927: if (nt->nt_local & LPRTERA) {
928: if (!(nt->nt_lstate & LSERASE)) {
929: (void) putd (putq, nt->nt_outq, '\\');
930: nt->nt_lstate |= LSERASE;
931: }
932: ntecho (c, nt);
933: return;
934: }
935:
936: if (!(nt->nt_local & LCRTBS)) {
937: ntecho (nt->nt_erase, nt);
938: return;
939: }
940:
941: if (nt->nt_trash > nt->nt_nin) {
942: ntreprint (nt);
943: return;
944: }
945:
946: if (c == ('\t'|0200) || c == ('\n'|0200)) {
947: ntbs (nt, 2);
948: return;
949: }
950:
951: switch (partab[c&=0177] & 0177) {
952: case ORDINARY:
953: if (nt->nt_flags&LCASE && c >= 'A' && c <= 'Z')
954: ntbs (nt, 2);
955: else ntbs (nt, 1);
956: break;
957: case TAB:
958: for (col = nt->nt_rocol, i = 0; i < nt->nt_nin; i++) {
959: cc = nt->nt_in[i];
960: if (cc == ('\t'|0200) || cc == ('\n'|0200)) {
961: col += 2;
962: continue;
963: }
964: switch (partab[cc&=0177] & 0177) {
965: case ORDINARY:
966: if (nt->nt_flags&LCASE && cc>='A' && cc<='Z')
967: col += 2;
968: else col++;
969: break;
970: case TAB:
971: col = (col + 8) & ~7;
972: break;
973: default:
974: if (nt->nt_local & LCTLECH)
975: col += 2;
976: break;
977: }
978: }
979: ntbs (nt, 8 - (col & 7));
980: break;
981: default:
982: if (nt->nt_local & LCTLECH)
983: ntbs (nt, 2);
984: break;
985: }
986:
987: return;
988: }
989:
990:
991: /*
992: * Interpret the control characters that cause signals to be generated
993: * immediately: interrupt (^?), quit (^\), stop (^Z).
994: * Called from ntinc().
995: */
996:
997: int
998: ntsigc (c, nt)
999: register c;
1000: register struct nttyld *nt;
1001: {
1002: if (c == nt->nt_intrc) {
1003: ntflush (nt, FREAD | FWRITE);
1004: (void) putctl1 (nt->nt_readq->next, M_SIGNAL, SIGINT);
1005: }
1006: else if (c == nt->nt_quitc) {
1007: ntflush (nt, FREAD | FWRITE);
1008: (void) putctl1 (nt->nt_readq->next, M_SIGNAL, SIGQUIT);
1009: }
1010: else if (c == nt->nt_suspc) {
1011: ntflush (nt, FREAD);
1012: (void) putctl1 (nt->nt_readq->next, M_SIGNAL, SIGTSTP);
1013: }
1014: else return (0);
1015:
1016: ntecho (c, nt);
1017: return (1);
1018: }
1019:
1020:
1021: /*
1022: * Interpret the start (^S) and stop (^Q) control characters.
1023: * Called from ntinc().
1024: */
1025:
1026: int
1027: ntstst (c, nt)
1028: register int c;
1029: register struct nttyld *nt;
1030: {
1031: if (nt->nt_state & NT_STOP) {
1032: if (c == nt->nt_startc ||
1033: !(nt->nt_local & LDECCTQ) &&
1034: (c != nt->nt_stopc || nt->nt_stopc == nt->nt_startc)) {
1035: if (putctl (nt->nt_outq->next, M_START))
1036: nt->nt_state &= ~NT_STOP;
1037: }
1038: }
1039: else if (c == nt->nt_stopc) {
1040: if (putctl (nt->nt_outq->next, M_STOP))
1041: nt->nt_state |= NT_STOP;
1042: }
1043:
1044: return (c == nt->nt_startc || c == nt->nt_stopc);
1045: }
1046:
1047:
1048: /*
1049: * Erase the last word of the input buffer.
1050: * Called from ntinc().
1051: */
1052:
1053: ntwerase (nt)
1054: register struct nttyld *nt;
1055: {
1056: register char *s;
1057:
1058: for (s = nt->nt_in + nt->nt_nin - 1; s >= nt->nt_in; s--)
1059: if (*s == ' ' || *s == '\t')
1060: ntrubout (nt);
1061: else break;
1062:
1063: for (; s >= nt->nt_in; s--)
1064: if (*s == ' ' || *s == '\t')
1065: break;
1066: else ntrubout (nt);
1067:
1068: return;
1069: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.