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