![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tty.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Atari MiNT] / MiNT / src|
Return to tty.c CVS log | Up to [Atari MiNT] / MiNT / src |
1.1 root 1: /*
2:
3: Copyright 1990,1991,1992 Eric R. Smith. All rights reserved.
4:
5: */
6:
7:
8:
9: /*
10:
11: * read/write routines for TTY devices
12:
13: */
14:
15:
16:
17: #include "mint.h"
18:
19:
20:
21: static void _erase P_((FILEPTR *, int));
22:
23: static int escseq P_((struct tty *, int));
24:
25:
26:
27: /* setting a special character to this value disables it */
28:
29: #define UNDEF 0
30:
31:
32:
33:
34:
35: /* default terminal characteristics */
36:
37:
38:
39: struct tty default_tty = {
40:
41: 0, /* process group */
42:
43: 0, /* state */
44:
45: 0, /* use_cnt */
46:
47: 0, /* reserved short */
48:
49: {
50:
51: 13, 13, /* input speed == output speed == 9600 baud */
52:
53: CTRL('H'), /* erase */
54:
55: CTRL('U'), /* kill */
56:
57: T_ECHO|T_CRMOD|T_TOSTOP|T_XKEY, /* flags */
58:
59: },
60:
61: {
62:
63: CTRL('C'), /* interrupt */
64:
65: CTRL('\\'), /* quit */
66:
67: CTRL('Q'), /* start */
68:
69: CTRL('S'), /* stop */
70:
71: CTRL('D'), /* EOF */
72:
73: '\r' /* alternate end of line */
74:
75: },
76:
77: {
78:
79: CTRL('Z'), /* suspend */
80:
81: CTRL('Y'), /* suspend after read */
82:
83: CTRL('R'), /* reprint */
84:
85: UNDEF, /* flush output */
86:
87: UNDEF, /* erase word */
88:
89: UNDEF /* quote next char */
90:
91: },
92:
93: {
94:
95: 0, 0, 0, 0 /* window size is unknown */
96:
97: },
98:
99: 0, /* no process is selecting us for reading */
100:
101: 0, /* or for writing */
102:
103: 0 /* use default XKEY map */
104:
105: };
106:
107:
108:
109: #define _put(f, c) (tty_putchar((f), (c), RAW))
110:
111:
112:
113: static void
114:
115: _erase(f, c)
116:
117: FILEPTR *f;
118:
119: int c;
120:
121: {
122:
123: _put(f, '\010');
124:
125: _put(f, ' ');
126:
127: _put(f, '\010');
128:
129: /* watch out for control characters -- they're printed as e.g. "^C" */
130:
131: if (c >= 0 && c < ' ') {
132:
133: _put(f, '\010'); _put(f, ' '); _put(f, '\010');
134:
135: }
136:
137: }
138:
139:
140:
141: #define put(f, c) { if (mode & T_ECHO) _put(f, c); }
142:
143: #define erase(f, c) { if (mode & T_ECHO) _erase(f, c); }
144:
145:
146:
147: long
148:
149: tty_read(f, buf, nbytes)
150:
151: FILEPTR *f;
152:
153: void *buf;
154:
155: long nbytes;
156:
157: {
158:
159: long r;
160:
161: long bytes_read = 0;
162:
163: unsigned char ch, *ptr;
164:
165: int rdmode, mode;
166:
167: struct tty *tty;
168:
169:
170:
171: tty = (struct tty *)f->devinfo;
172:
173: assert(tty != 0);
174:
175:
176:
177: if (f->flags & O_HEAD) { /* pty server side? */
178:
179: rdmode = RAW; /* yes -- always raw mode */
180:
181: mode = T_RAW;
182:
183: }
184:
185: else if (curproc->domain == DOM_MINT) { /* MiNT domain process? */
186:
187: mode = tty->sg.sg_flags;
188:
189: rdmode = COOKED|NOECHO;
190:
191: if ( mode & (T_RAW | T_CBREAK) ) {
192:
193: rdmode = (mode & T_RAW) ? RAW : COOKED;
194:
195: }
196:
197: if (mode & T_XKEY)
198:
199: rdmode |= ESCSEQ;
200:
201: }
202:
203: else {
204:
205: rdmode = COOKED|NOECHO;
206:
207: mode = T_TOS | T_ECHO;
208:
209: }
210:
211:
212:
213: ptr = buf;
214:
215:
216:
217: while (bytes_read < nbytes) {
218:
219: r = tty_getchar(f, rdmode);
220:
221: if (r < 0) {
222:
223: DEBUG("tty_read: tty_getchar returned %ld", r);
224:
225: return (bytes_read) ? bytes_read : r;
226:
227: }
228:
229: else if (r == MiNTEOF)
230:
231: return bytes_read;
232:
233: ch = r & 0xff;
234:
235:
236:
237: if ( (mode & T_CRMOD) && (ch == '\r') )
238:
239: ch = '\n';
240:
241:
242:
243: /* 1 character reads in TOS mode are always raw */
244:
245: if (nbytes == 1 && (mode & T_TOS)) {
246:
247: put(f, ch);
248:
249: *ptr = ch;
250:
251: return 1;
252:
253: }
254:
255:
256:
257: /* T_CBREAK mode doesn't do erase or kill processing */
258:
259: /* also note that setting a special character to UNDEF disables it */
260:
261:
262:
263: if (rdmode & COOKED && !(mode & T_CBREAK) && ch != UNDEF) {
264:
265: if ((char)ch == tty->sg.sg_erase) { /* backspace */
266:
267: if (bytes_read > 0) {
268:
269: --ptr;
270:
271: erase(f, *ptr);
272:
273: bytes_read--;
274:
275: }
276:
277: continue;
278:
279: }
280:
281: else if (ch == CTRL('X')) {
282:
283: while (bytes_read > 0) {
284:
285: --ptr;
286:
287: erase(f, *ptr);
288:
289: bytes_read--;
290:
291: }
292:
293: continue;
294:
295: }
296:
297: else if ((char)ch ==tty->ltc.t_rprntc ||
298:
299: (char)ch == tty->sg.sg_kill) {
300:
301: if (mode & T_TOS)
302:
303: put(f, '#');
304:
305: put(f, '\r');
306:
307: put(f, '\n');
308:
309: ptr = buf;
310:
311: if ((char)ch == tty->sg.sg_kill) {
312:
313: bytes_read = 0;
314:
315: }
316:
317: else {
318:
319: for (r = 0; r < bytes_read; r++, ptr++)
320:
321: put(f, *ptr);
322:
323: }
324:
325: continue;
326:
327: }
328:
329: else if ((char)ch == tty->tc.t_eofc && !(mode & T_TOS))
330:
331: return bytes_read;
332:
333: }
334:
335:
336:
337: /* both T_CBREAK and T_COOKED modes have to do signals, though */
338:
339: if ((rdmode & COOKED) && ch != UNDEF) {
340:
341: if ((char)ch == tty->tc.t_intrc
342:
343: || (char)ch == tty->tc.t_quitc
344:
345: || (char)ch == tty->ltc.t_dsuspc
346:
347: || (char)ch == tty->ltc.t_suspc
348:
349: ) {
350:
351: /* the device driver raised the appropriate signal; if we get here, the
352:
353: signal was caught by the user (or ignored). flush buffers and continue
354:
355: */
356:
357: if (!(tty->sg.sg_flags & T_NOFLSH)) {
358:
359: DEBUG("tty_read: flushing input");
360:
361: bytes_read = 0;
362:
363: ptr = buf;
364:
365: }
366:
367: continue;
368:
369: }
370:
371: else if (ch == '\n' || (char)ch == tty->tc.t_brkc) {
372:
373: put(f, '\r');
374:
375: if (!(mode & T_TOS)) {
376:
377: *ptr++ = ch;
378:
379: put(f, '\n');
380:
381: bytes_read++;
382:
383: }
384:
385: return bytes_read;
386:
387: }
388:
389:
390:
391: }
392:
393:
394:
395: /* do the following for both RAW and COOKED mode */
396:
397: *ptr++ = ch;
398:
399: if (ch < ' ') { /* ch is unsigned */
400:
401: put(f, '^'); put(f, ch+'@');
402:
403: }
404:
405: else
406:
407: put(f, ch);
408:
409: bytes_read++;
410:
411:
412:
413: /* for RAW mode, if there are no more characters then break */
414:
415: if ( (mode & (T_RAW|T_CBREAK)) &&
416:
417: !((rdmode & ESCSEQ) && (tty->state & TS_ESC))) {
418:
419: r = 1;
420:
421: (void)(*f->dev->ioctl)(f, FIONREAD, &r);
422:
423: if (r <= 0) break;
424:
425: }
426:
427: }
428:
429:
430:
431: return bytes_read;
432:
433: }
434:
435:
436:
437: long
438:
439: tty_write(f, buf, nbytes)
440:
441: FILEPTR *f;
442:
443: const void *buf;
444:
445: long nbytes;
446:
447: {
448:
449: unsigned const char *ptr;
450:
451: long c;
452:
453: long bytes_written;
454:
455: int mode, rwmode;
456:
457: struct tty *tty;
458:
459: int use_putchar = 0;
460:
461: static long cr_char = '\r';
462:
463: #define LBUFSIZ 128
464:
465: long lbuf[LBUFSIZ];
466:
467:
468:
469: tty = (struct tty *)f->devinfo;
470:
471: assert(tty != 0);
472:
473:
474:
475: ptr = buf;
476:
477: if (f->flags & O_HEAD) {
478:
479: use_putchar = 1;
480:
481: mode = T_RAW;
482:
483: }
484:
485: else if (curproc->domain == DOM_TOS)
486:
487: /* for TOS programs, 1 byte writes are always in raw mode */
488:
489: mode = (nbytes == 1) ? T_RAW : T_TOS;
490:
491: else
492:
493: mode = tty->sg.sg_flags;
494:
495:
496:
497: rwmode = (mode & T_RAW) ? RAW : COOKED;
498:
499:
500:
501: bytes_written = 0;
502:
503:
504:
505: /*
506:
507: * "mode" can now be reduced to just T_CRMODE or not
508:
509: */
510:
511: if ((curproc->domain == DOM_MINT) && (mode & T_CRMOD) &&
512:
513: !(mode & T_RAW))
514:
515: mode = T_CRMOD;
516:
517: else
518:
519: mode = 0;
520:
521:
522:
523: /*
524:
525: * we always write at least 1 byte with tty_putchar, since that takes
526:
527: * care of job control and terminal states. After that, we may be able
528:
529: * to use (*f->dev->write) directly.
530:
531: */
532:
533:
534:
535:
536:
537: if (nbytes == 0) return bytes_written;
538:
539: c = *ptr++;
540:
541:
542:
543: if (c == '\n' && mode) { /* remember, "mode" now means CRMOD */
544:
545: tty_putchar(f, cr_char, rwmode);
546:
547: }
548:
549: tty_putchar(f, c, rwmode);
550:
551: nbytes--;
552:
553: bytes_written++;
554:
555:
556:
557: if (use_putchar) {
558:
559: while (nbytes-- > 0) {
560:
561: c = *ptr++;
562:
563: if (c == '\n' && mode)
564:
565: tty_putchar(f, cr_char, rwmode);
566:
567: tty_putchar(f, c, rwmode);
568:
569: bytes_written++;
570:
571: }
572:
573: } else {
574:
575: /* write in big chunks if possible; but never more than 1 line
576:
577: * (so that ^S/^Q can happen reasonably quickly for the user)
578:
579: */
580:
581: long bytes_to_write = 0;
582:
583: long *s = lbuf;
584:
585:
586:
587: while (nbytes-- > 0) {
588:
589: c = *ptr++;
590:
591: if (c == '\n') {
592:
593: if (bytes_to_write) {
594:
595: (*f->dev->write)(f, (char *)lbuf,
596:
597: bytes_to_write);
598:
599: bytes_to_write = 0;
600:
601: s = lbuf;
602:
603: }
604:
605: if (mode) /* i.e. T_CRMODE */
606:
607: tty_putchar(f, cr_char, rwmode);
608:
609: tty_putchar(f, (long)c, rwmode);
610:
611: bytes_written++;
612:
613: } else {
614:
615: *s++ = c;
616:
617: bytes_written++;
618:
619: bytes_to_write += 4;
620:
621: if (bytes_to_write >= LBUFSIZ*4) {
622:
623: (*f->dev->write)(f, (char *)lbuf,
624:
625: bytes_to_write);
626:
627: bytes_to_write = 0;
628:
629: s = lbuf;
630:
631: }
632:
633: }
634:
635: }
636:
637: if (bytes_to_write) {
638:
639: (*f->dev->write)(f, (char *)lbuf, bytes_to_write);
640:
641: }
642:
643: }
644:
645:
646:
647: return bytes_written;
648:
649: }
650:
651:
652:
653: /* some notable scan codes */
654:
655: #define K_INSERT 0x52
656:
657: #define K_HOME 0x47
658:
659: #define K_UNDO 0x61
660:
661: #define K_HELP 0x62
662:
663: #define CURS_UP 0x48
664:
665: #define CURS_DN 0x50
666:
667: #define CURS_RT 0x4d
668:
669: #define CURS_LF 0x4b
670:
671: #define F_1 0x3b
672:
673: #define F_10 0x44
674:
675: #define F_11 0x54
676:
677: #define F_20 0x5d
678:
679: #define ALT_1 0x78
680:
681: #define ALT_0 0x81
682:
683:
684:
685: /* Default function key table:
686:
687: * entries: 0-9 are F1-F10
688:
689: * 10-19 are F11-F20
690:
691: * 20-23 are cursor up, down, right, and left
692:
693: * 24-27 are help, undo, insert, and home
694:
695: * 28-31 are shift+cursor up, down, right, and left
696:
697: */
698:
699:
700:
701: static char vt52xkey[256] = {
702:
703: '\033', 'P', 0, 0, 0, 0, 0, 0,
704:
705: '\033', 'Q', 0, 0, 0, 0, 0, 0,
706:
707: '\033', 'R', 0, 0, 0, 0, 0, 0,
708:
709: '\033', 'S', 0, 0, 0, 0, 0, 0,
710:
711: '\033', 'T', 0, 0, 0, 0, 0, 0,
712:
713: '\033', 'U', 0, 0, 0, 0, 0, 0,
714:
715: '\033', 'V', 0, 0, 0, 0, 0, 0,
716:
717: '\033', 'W', 0, 0, 0, 0, 0, 0,
718:
719: '\033', 'X', 0, 0, 0, 0, 0, 0,
720:
721: '\033', 'Y', 0, 0, 0, 0, 0, 0,
722:
723: '\033', 'p', 0, 0, 0, 0, 0, 0,
724:
725: '\033', 'q', 0, 0, 0, 0, 0, 0,
726:
727: '\033', 'r', 0, 0, 0, 0, 0, 0,
728:
729: '\033', 's', 0, 0, 0, 0, 0, 0,
730:
731: '\033', 't', 0, 0, 0, 0, 0, 0,
732:
733: '\033', 'u', 0, 0, 0, 0, 0, 0,
734:
735: '\033', 'v', 0, 0, 0, 0, 0, 0,
736:
737: '\033', 'w', 0, 0, 0, 0, 0, 0,
738:
739: '\033', 'x', 0, 0, 0, 0, 0, 0,
740:
741: '\033', 'y', 0, 0, 0, 0, 0, 0,
742:
743: '\033', 'A', 0, 0, 0, 0, 0, 0,
744:
745: '\033', 'B', 0, 0, 0, 0, 0, 0,
746:
747: '\033', 'C', 0, 0, 0, 0, 0, 0,
748:
749: '\033', 'D', 0, 0, 0, 0, 0, 0,
750:
751: '\033', 'H', 0, 0, 0, 0, 0, 0,
752:
753: '\033', 'K', 0, 0, 0, 0, 0, 0,
754:
755: '\033', 'I', 0, 0, 0, 0, 0, 0,
756:
757: '\033', 'E', 0, 0, 0, 0, 0, 0,
758:
759: '\033', 'a', 0, 0, 0, 0, 0, 0,
760:
761: '\033', 'b', 0, 0, 0, 0, 0, 0,
762:
763: '\033', 'c', 0, 0, 0, 0, 0, 0,
764:
765: '\033', 'd', 0, 0, 0, 0, 0, 0,
766:
767: };
768:
769:
770:
771: static char unxbaud P_((long));
772:
773:
774:
775: /* convert a number describing the baud rate into a Unix
776:
777: * style baud rate number. Returns the Unix baud rate,
778:
779: * or 16 (EXTA) if the rate is unknown
780:
781: */
782:
783:
784:
785: #define EXTA 16
786:
787:
788:
789: static long ubaud[EXTA] = {
790:
791: 0L, 50L, 75L, 110L, 134L, 150L, 200L, 300L,
792:
793: 600L, 1200L, 1800L, 2400L, 4800L, 9600L, 19200L, 38400L
794:
795: };
796:
797:
798:
799: static char
800:
801: unxbaud(baud)
802:
803: long baud;
804:
805: {
806:
807: int i;
808:
809: for (i = 1; i < EXTA; i++) {
810:
811: if (ubaud[i] == baud)
812:
813: break;
814:
815: }
816:
817: return i;
818:
819: }
820:
821:
822:
823: #define tosbaud(c) ( ((c) < 0 || (c) >= EXTA) ? -1L : ubaud[c] )
824:
825:
826:
827: long
828:
829: tty_ioctl(f, mode, arg)
830:
831: FILEPTR *f;
832:
833: int mode;
834:
835: void *arg;
836:
837: {
838:
839: struct sgttyb *sg;
840:
841: struct tchars *tc;
842:
843: struct ltchars *ltc;
844:
845: struct tty *tty;
846:
847: struct winsize *sz;
848:
849: struct xkey *xk;
850:
851: char *xktab;
852:
853: int i;
854:
855: long baud;
856:
857: short flags;
858:
859:
860:
861: if (!is_terminal(f)) {
862:
863: DEBUG("tty_ioctl(mode %x): file is not a tty", mode);
864:
865: return EINVFN;
866:
867: }
868:
869: tty = (struct tty *)f->devinfo;
870:
871: assert(tty != 0);
872:
873:
874:
875: switch(mode) {
876:
877: case TIOCGETP:
878:
879: sg = (struct sgttyb *)arg;
880:
881: /* get input and output baud rates from the terminal device */
882:
883: baud = -1L;
884:
885: (*f->dev->ioctl)(f, TIOCIBAUD, &baud);
886:
887: tty->sg.sg_ispeed = unxbaud(baud);
888:
889: baud = -1L;
890:
891: (*f->dev->ioctl)(f, TIOCOBAUD, &baud);
892:
893: tty->sg.sg_ospeed = unxbaud(baud);
894:
895: /* get terminal flags */
896:
897: flags = 0;
898:
899: if ((*f->dev->ioctl)(f, TIOCGFLAGS, &flags) == 0) {
900:
901: tty->sg.sg_flags &= ~TF_FLAGS;
902:
903: tty->sg.sg_flags |= (flags & TF_FLAGS);
904:
905: }
906:
907: *sg = tty->sg;
908:
909: return 0;
910:
911: case TIOCSETP:
912:
913: sg = (struct sgttyb *)arg;
914:
915: tty->sg = *sg;
916:
917: /* set baud rates */
918:
919: baud = tosbaud(sg->sg_ispeed);
920:
921: (*f->dev->ioctl)(f, TIOCIBAUD, &baud);
922:
923: baud = tosbaud(sg->sg_ospeed);
924:
925: (*f->dev->ioctl)(f, TIOCOBAUD, &baud);
926:
927: /* set parity, etc. */
928:
929: flags = TF_8BIT;
930:
931: if (sg->sg_flags & (T_EVENP|T_ODDP)) {
932:
933: flags = TF_7BIT;
934:
935: }
936:
937: flags |= (sg->sg_flags & TF_FLAGS);
938:
939: (*f->dev->ioctl)(f, TIOCSFLAGS, &flags);
940:
941: return 0;
942:
943: case TIOCGETC:
944:
945: tc = (struct tchars *)arg;
946:
947: *tc = tty->tc;
948:
949: return 0;
950:
951: case TIOCSETC:
952:
953: tc = (struct tchars *)arg;
954:
955: tty->tc = *tc;
956:
957: return 0;
958:
959: case TIOCGLTC:
960:
961: ltc = (struct ltchars *)arg;
962:
963: *ltc = tty->ltc;
964:
965: return 0;
966:
967: case TIOCSLTC:
968:
969: ltc = (struct ltchars *)arg;
970:
971: tty->ltc = *ltc;
972:
973: return 0;
974:
975: case TIOCGWINSZ:
976:
977: sz = (struct winsize *)arg;
978:
979: *sz = tty->wsiz;
980:
981: return 0;
982:
983: case TIOCSWINSZ:
984:
985: sz = (struct winsize *)arg;
986:
987: tty->wsiz = *sz;
988:
989: return 0;
990:
991: case TIOCGPGRP:
992:
993: *((long *)arg) = tty->pgrp;
994:
995: return 0;
996:
997: case TIOCSPGRP:
998:
999: tty->pgrp = (*((long *)arg) & 0x00007fffL);
1000:
1001: return 0;
1002:
1003: case TIOCSTART:
1004:
1005: tty->state &= ~TS_HOLD;
1006:
1007: return 0;
1008:
1009: case TIOCSTOP:
1010:
1011: tty->state |= TS_HOLD;
1012:
1013: return 0;
1014:
1015: case TIOCGXKEY:
1016:
1017: xk = (struct xkey *)arg;
1018:
1019: i = xk->xk_num;
1020:
1021: if (i < 0 || i > 31) return ERANGE;
1022:
1023: xktab = tty->xkey;
1024:
1025: if (!xktab) xktab = vt52xkey;
1026:
1027: xktab += i*8;
1028:
1029: for (i = 0; i < 8; i++)
1030:
1031: xk->xk_def[i] = *xktab++;
1032:
1033: return 0;
1034:
1035: case TIOCSXKEY:
1036:
1037: xk = (struct xkey *)arg;
1038:
1039: xktab = tty->xkey;
1040:
1041: if (!xktab) {
1042:
1043: xktab = kmalloc((long)256);
1044:
1045: if (!xktab) return ENSMEM;
1046:
1047: for (i = 0; i < 256; i++)
1048:
1049: xktab[i] = vt52xkey[i];
1050:
1051: tty->xkey = xktab;
1052:
1053: }
1054:
1055: i = xk->xk_num;
1056:
1057: if (i < 0 || i > 31) return ERANGE;
1058:
1059: xktab += i*8;
1060:
1061: for (i = 0; i < 7; i++)
1062:
1063: xktab[i] = xk->xk_def[i];
1064:
1065: xktab[7] = 0;
1066:
1067: return 0;
1068:
1069: default:
1070:
1071: DEBUG("tty_ioctl: bad function call");
1072:
1073: return EINVFN;
1074:
1075: }
1076:
1077: }
1078:
1079:
1080:
1081: /*
1082:
1083: * function for translating extended characters (e.g. cursor keys, or
1084:
1085: * ALT+key sequences) into either escape sequences or meta characters.
1086:
1087: * for escape sequences, we return the the first character of the
1088:
1089: * sequence (normally ESC) and set the tty's state so that subsequent
1090:
1091: * calls to tty_getchar will pick up the remaining characters.
1092:
1093: * Note that escape sequences are limited to 7 characters at most.
1094:
1095: */
1096:
1097:
1098:
1099: static int
1100:
1101: escseq(tty, scan)
1102:
1103: struct tty *tty;
1104:
1105: int scan;
1106:
1107: {
1108:
1109: char *tab;
1110:
1111: int i;
1112:
1113:
1114:
1115: switch(scan) {
1116:
1117: case CURS_UP: i = 20; break;
1118:
1119: case CURS_DN: i = 21; break;
1120:
1121: case CURS_RT: i = 22; break;
1122:
1123: case CURS_LF: i = 23; break;
1124:
1125: case K_HELP: i = 24; break;
1126:
1127: case K_UNDO: i = 25; break;
1128:
1129: case K_INSERT:i = 26; break;
1130:
1131: case K_HOME: i = 27; break;
1132:
1133: case CURS_UP+0x100: i = 28; break;
1134:
1135: case CURS_DN+0x100: i = 29; break;
1136:
1137: case CURS_RT+0x100: i = 30; break;
1138:
1139: case CURS_LF+0x100: i = 31; break;
1140:
1141: default:
1142:
1143: if (scan >= F_1 && scan <= F_10) {
1144:
1145: i = scan - F_1;
1146:
1147: } else if (scan >= F_11 && scan <= F_20) {
1148:
1149: i = 10 + scan - F_11;
1150:
1151: } else
1152:
1153: i = -1;
1154:
1155: }
1156:
1157:
1158:
1159: if (i >= 0) { /* an extended escape sequence */
1160:
1161: tab = tty->xkey;
1162:
1163: if (!tab) tab = vt52xkey;
1164:
1165: i *= 8;
1166:
1167: scan = tab[i++];
1168:
1169: if (scan) {
1170:
1171: if (tab[i] == 0) i = 0;
1172:
1173: tty->state = (tty->state & ~TS_ESC) | i;
1174:
1175: }
1176:
1177: return scan;
1178:
1179: }
1180:
1181:
1182:
1183: if (scan >= ALT_1 && scan <= ALT_0) {
1184:
1185: scan -= (ALT_1-1);
1186:
1187: if (scan == 10) scan = 0;
1188:
1189: return (scan + '0') | 0x80;
1190:
1191: }
1192:
1193:
1194:
1195: tab = *( ((char **)Keytbl((void *)-1L, (void *)-1L, (void *)-1L)) + 2 ); /* gratuitous (void *) for Lattice */
1196:
1197: scan = tab[scan];
1198:
1199: if (scan >= 'A' && scan <= 'Z') return scan | 0x80;
1200:
1201: return 0;
1202:
1203: }
1204:
1205:
1206:
1207: long
1208:
1209: tty_getchar(f, mode)
1210:
1211: FILEPTR *f;
1212:
1213: int mode;
1214:
1215: {
1216:
1217: struct tty *tty = (struct tty *)f->devinfo;
1218:
1219: char c, *tab;
1220:
1221: long r, ret;
1222:
1223: int scan;
1224:
1225: int master = f->flags & O_HEAD;
1226:
1227:
1228:
1229: assert(tty);
1230:
1231:
1232:
1233: /* pty masters never worry about job control and always read in raw mode */
1234:
1235: if (master) {
1236:
1237: ret = (*f->dev->read)(f, (char *)&r, 4L);
1238:
1239: return (ret != 4L) ? MiNTEOF : r;
1240:
1241: }
1242:
1243:
1244:
1245: /* job control check */
1246:
1247: if (tty->pgrp != curproc->pgrp && tty->pgrp > 0) {
1248:
1249: TRACE("job control: tty pgrp is %d proc pgrp is %d",
1250:
1251: tty->pgrp, curproc->pgrp);
1252:
1253: killgroup(curproc->pgrp, SIGTTIN);
1254:
1255: }
1256:
1257:
1258:
1259: if (mode & COOKED)
1260:
1261: tty->state |= TS_COOKED;
1262:
1263: else
1264:
1265: tty->state &= ~TS_COOKED;
1266:
1267:
1268:
1269: c = UNDEF+1; /* set to UNDEF when we successfully read a character */
1270:
1271:
1272:
1273: /* we may be in the middle of an escape sequence */
1274:
1275: if (scan = (tty->state & TS_ESC)) {
1276:
1277: if (mode & ESCSEQ) {
1278:
1279: tab = tty->xkey ? tty->xkey : vt52xkey;
1280:
1281: r = (unsigned char) tab[scan++];
1282:
1283: if (r) {
1284:
1285: c = UNDEF;
1286:
1287: if (tab[scan] == 0) scan = 0;
1288:
1289: }
1290:
1291: else
1292:
1293: scan = 0;
1294:
1295: tty->state = (tty->state & ~TS_ESC) | scan;
1296:
1297: }
1298:
1299: else
1300:
1301: tty->state &= ~TS_ESC;
1302:
1303: }
1304:
1305:
1306:
1307: while (c != UNDEF) {
1308:
1309: ret = (*f->dev->read)(f, (char *)&r, 4L);
1310:
1311: if (ret != 4L) {
1312:
1313: DEBUG("EOF on tty device");
1314:
1315: return MiNTEOF;
1316:
1317: }
1318:
1319: c = r & 0x00ff;
1320:
1321: scan = (r & 0x00ff0000) >> 16;
1322:
1323: if ( (c == 0) && (mode & ESCSEQ) && scan) {
1324:
1325: c = UNDEF;
1326:
1327: /* translate cursor keys, etc. into escape sequences or
1328:
1329: * META characters
1330:
1331: */
1332:
1333: r = escseq(tty, scan);
1334:
1335: } else if ((mode & ESCSEQ) && ((scan == CURS_UP && c == '8') ||
1336:
1337: (scan == CURS_DN && c == '2') ||
1338:
1339: (scan == CURS_RT && c == '6') ||
1340:
1341: (scan == CURS_LF && c == '4'))) {
1342:
1343: c = UNDEF;
1344:
1345: r = escseq(tty, scan+0x100);
1346:
1347: } else if (mode & COOKED) {
1348:
1349: if (c == UNDEF)
1350:
1351: ; /* do nothing */
1352:
1353: else if (c == tty->ltc.t_dsuspc)
1354:
1355: killgroup(curproc->pgrp, SIGTSTP);
1356:
1357: else if (c == tty->tc.t_intrc)
1358:
1359: killgroup(curproc->pgrp, SIGINT);
1360:
1361: else if (c == tty->tc.t_stopc)
1362:
1363: tty->state |= TS_HOLD;
1364:
1365: else if (c == tty->tc.t_stopc)
1366:
1367: tty->state &= ~TS_HOLD;
1368:
1369: else
1370:
1371: c = UNDEF;
1372:
1373: }
1374:
1375: else
1376:
1377: c = UNDEF;
1378:
1379: }
1380:
1381:
1382:
1383: if (mode & ECHO)
1384:
1385: tty_putchar(f, r, mode);
1386:
1387:
1388:
1389: return r;
1390:
1391: }
1392:
1393:
1394:
1395: /*
1396:
1397: * tty_putchar: returns number of bytes successfully written
1398:
1399: */
1400:
1401:
1402:
1403: long
1404:
1405: tty_putchar(f, data, mode)
1406:
1407: FILEPTR *f;
1408:
1409: long data;
1410:
1411: int mode;
1412:
1413: {
1414:
1415: struct tty *tty;
1416:
1417: int master; /* file is pty master side */
1418:
1419: char ch;
1420:
1421:
1422:
1423: tty = (struct tty *)f->devinfo;
1424:
1425:
1426:
1427: master = f->flags & O_HEAD;
1428:
1429:
1430:
1431: /* pty masters don't need to worry about job control */
1432:
1433: if (master) {
1434:
1435: ch = data & 0xff;
1436:
1437:
1438:
1439: if ( (tty->state & TS_COOKED) && ch != UNDEF) {
1440:
1441: /* see if we're putting control characters into the buffer */
1442:
1443: if (ch == tty->tc.t_intrc) {
1444:
1445: tty->state &= ~TS_HOLD;
1446:
1447: killgroup(tty->pgrp, SIGINT);
1448:
1449: return 4L;
1450:
1451: }
1452:
1453: else if (ch == tty->tc.t_quitc) {
1454:
1455: tty->state &= ~TS_HOLD;
1456:
1457: killgroup(tty->pgrp, SIGQUIT);
1458:
1459: return 4L;
1460:
1461: }
1462:
1463: else if (ch == tty->ltc.t_suspc) {
1464:
1465: tty->state &= ~TS_HOLD;
1466:
1467: killgroup(tty->pgrp, SIGTSTP);
1468:
1469: return 4L;
1470:
1471: }
1472:
1473: else if (ch == tty->tc.t_stopc) {
1474:
1475: tty->state |= TS_HOLD;
1476:
1477: return 4L;
1478:
1479: }
1480:
1481: else if (ch == tty->tc.t_startc) {
1482:
1483: tty->state &= ~TS_HOLD;
1484:
1485: return 4L;
1486:
1487: }
1488:
1489: else if (tty->state & TS_HOLD) {
1490:
1491: return 0;
1492:
1493: }
1494:
1495: }
1496:
1497: goto do_putchar;
1498:
1499: }
1500:
1501: /* job control checks */
1502:
1503: /* AKP: added T_TOSTOP; don't stop BG output if T_TOSTOP is clear */
1504:
1505: if (tty->pgrp != curproc->pgrp && tty->pgrp > 0
1506:
1507: && (tty->sg.sg_flags & T_TOSTOP)) {
1508:
1509: TRACE("job control: tty pgrp is %d proc pgrp is %d",
1510:
1511: tty->pgrp, curproc->pgrp);
1512:
1513: killgroup(curproc->pgrp, SIGTTOU);
1514:
1515: }
1516:
1517:
1518:
1519: if (mode & COOKED) {
1520:
1521: tty->state |= TS_COOKED;
1522:
1523: while (tty->state & TS_HOLD)
1524:
1525: nap(60); /* sleep for 60 milliseconds */
1526:
1527: }
1528:
1529: else
1530:
1531: tty->state &= ~TS_COOKED;
1532:
1533:
1534:
1535: do_putchar:
1536:
1537: return (*f->dev->write)(f, (char *)&data, 4L);
1538:
1539: }
1540:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.