1 /* 2 * Copyright (c) 1980 Regents of the University of California. 3 * All rights reserved. The Berkeley software License Agreement 4 * specifies the terms and conditions for redistribution. 5 */ 6 7 #ifndef lint 8 static char *sccsid = "@(#)ex_put.c 7.11 (Berkeley) 01/02/88"; 9 #endif not lint 10 11 #include "ex.h" 12 #include "ex_tty.h" 13 #include "ex_vis.h" 14 15 /* 16 * Terminal driving and line formatting routines. 17 * Basic motion optimizations are done here as well 18 * as formatting of lines (printing of control characters, 19 * line numbering and the like). 20 */ 21 22 /* 23 * The routines outchar, putchar and pline are actually 24 * variables, and these variables point at the current definitions 25 * of the routines. See the routine setflav. 26 * We sometimes make outchar be routines which catch the characters 27 * to be printed, e.g. if we want to see how long a line is. 28 * During open/visual, outchar and putchar will be set to 29 * routines in the file ex_vput.c (vputchar, vinschar, etc.). 30 */ 31 int (*Outchar)() = termchar; 32 int (*Put_char)() = normchar; 33 int (*Pline)() = normline; 34 35 int (* 36 setlist(t))() 37 bool t; 38 { 39 register int (*P)(); 40 41 listf = t; 42 P = Put_char; 43 Put_char = t ? listchar : normchar; 44 return (P); 45 } 46 47 int (* 48 setnumb(t))() 49 bool t; 50 { 51 register int (*P)(); 52 53 numberf = t; 54 P = Pline; 55 Pline = t ? numbline : normline; 56 return (P); 57 } 58 59 /* 60 * Format c for list mode; leave things in common 61 * with normal print mode to be done by normchar. 62 */ 63 listchar(c) 64 register short c; 65 { 66 67 c &= (TRIM|QUOTE); 68 switch (c) { 69 70 case '\t': 71 case '\b': 72 outchar('^'); 73 c = ctlof(c); 74 break; 75 76 case '\n': 77 break; 78 79 case '\n' | QUOTE: 80 outchar('$'); 81 break; 82 83 default: 84 if (c & QUOTE) 85 break; 86 if (c < ' ' && c != '\n' || c == DELETE) 87 outchar('^'), c = ctlof(c); 88 break; 89 } 90 normchar(c); 91 } 92 93 /* 94 * Format c for printing. Handle funnies of upper case terminals 95 * and crocky hazeltines which don't have ~. 96 */ 97 normchar(c) 98 register short c; 99 { 100 register char *colp; 101 102 c &= (TRIM|QUOTE); 103 if (c == '~' && HZ) { 104 normchar('\\'); 105 c = '^'; 106 } 107 if (c & QUOTE) 108 switch (c) { 109 110 case ' ' | QUOTE: 111 case '\b' | QUOTE: 112 break; 113 114 case QUOTE: 115 return; 116 117 default: 118 c &= TRIM; 119 } 120 else if (c < ' ' && (c != '\b' || !OS) && c != '\n' && c != '\t' || c == DELETE) 121 ex_putchar('^'), c = ctlof(c); 122 else if (UPPERCASE) 123 if (isupper(c)) { 124 outchar('\\'); 125 c = tolower(c); 126 } else { 127 colp = "({)}!|^~'`"; 128 while (*colp++) 129 if (c == *colp++) { 130 outchar('\\'); 131 c = colp[-2]; 132 break; 133 } 134 } 135 outchar(c); 136 } 137 138 /* 139 * Print a line with a number. 140 */ 141 numbline(i) 142 int i; 143 { 144 145 if (shudclob) 146 slobber(' '); 147 ex_printf("%6d ", i); 148 normline(); 149 } 150 151 /* 152 * Normal line output, no numbering. 153 */ 154 normline() 155 { 156 register char *cp; 157 158 if (shudclob) 159 slobber(linebuf[0]); 160 /* pdp-11 doprnt is not reentrant so can't use "printf" here 161 in case we are tracing */ 162 for (cp = linebuf; *cp;) 163 ex_putchar(*cp++); 164 if (!inopen) 165 ex_putchar('\n' | QUOTE); 166 } 167 168 /* 169 * Given c at the beginning of a line, determine whether 170 * the printing of the line will erase or otherwise obliterate 171 * the prompt which was printed before. If it won't, do it now. 172 */ 173 slobber(c) 174 int c; 175 { 176 177 shudclob = 0; 178 switch (c) { 179 180 case '\t': 181 if (Put_char == listchar) 182 return; 183 break; 184 185 default: 186 return; 187 188 case ' ': 189 case 0: 190 break; 191 } 192 if (OS) 193 return; 194 flush(); 195 putch(' '); 196 if (BC) 197 tputs(BC, 0, putch); 198 else 199 putch('\b'); 200 } 201 202 /* 203 * The output buffer is initialized with a useful error 204 * message so we don't have to keep it in data space. 205 */ 206 static char linb[66]; 207 char *linp = linb; 208 209 /* 210 * Phadnl records when we have already had a complete line ending with \n. 211 * If another line starts without a flush, and the terminal suggests it, 212 * we switch into -nl mode so that we can send lineffeeds to avoid 213 * a lot of spacing. 214 */ 215 static bool phadnl; 216 217 /* 218 * Indirect to current definition of putchar. 219 */ 220 ex_putchar(c) 221 int c; 222 { 223 224 (*Put_char)(c); 225 } 226 227 /* 228 * Termchar routine for command mode. 229 * Watch for possible switching to -nl mode. 230 * Otherwise flush into next level of buffering when 231 * small buffer fills or at a newline. 232 */ 233 termchar(c) 234 int c; 235 { 236 237 if (pfast == 0 && phadnl) 238 pstart(); 239 if (c == '\n') 240 phadnl = 1; 241 else if (linp >= &linb[63]) 242 flush1(); 243 *linp++ = c; 244 if (linp >= &linb[63]) { 245 fgoto(); 246 flush1(); 247 } 248 } 249 250 flush() 251 { 252 253 flush1(); 254 flush2(); 255 } 256 257 /* 258 * Flush from small line buffer into output buffer. 259 * Work here is destroying motion into positions, and then 260 * letting fgoto do the optimized motion. 261 */ 262 flush1() 263 { 264 register char *lp; 265 register short c; 266 267 *linp = 0; 268 lp = linb; 269 while (*lp) 270 switch (c = *lp++) { 271 272 case '\r': 273 destline += destcol / COLUMNS; 274 destcol = 0; 275 continue; 276 277 case '\b': 278 if (destcol) 279 destcol--; 280 continue; 281 282 case ' ': 283 destcol++; 284 continue; 285 286 case '\t': 287 destcol += value(TABSTOP) - destcol % value(TABSTOP); 288 continue; 289 290 case '\n': 291 destline += destcol / COLUMNS + 1; 292 if (destcol != 0 && destcol % COLUMNS == 0) 293 destline--; 294 destcol = 0; 295 continue; 296 297 default: 298 fgoto(); 299 for (;;) { 300 if (AM == 0 && outcol == COLUMNS) 301 fgoto(); 302 c &= TRIM; 303 putch(c); 304 if (c == '\b') { 305 outcol--; 306 destcol--; 307 } else if (c >= ' ' && c != DELETE) { 308 outcol++; 309 destcol++; 310 if (XN && outcol % COLUMNS == 0) 311 putch('\r'), putch('\n'); 312 } 313 c = *lp++; 314 if (c <= ' ') 315 break; 316 } 317 --lp; 318 continue; 319 } 320 linp = linb; 321 } 322 323 flush2() 324 { 325 326 fgoto(); 327 flusho(); 328 pstop(); 329 } 330 331 /* 332 * Sync the position of the output cursor. 333 * Most work here is rounding for terminal boundaries getting the 334 * column position implied by wraparound or the lack thereof and 335 * rolling up the screen to get destline on the screen. 336 */ 337 fgoto() 338 { 339 register int l, c; 340 341 if (destcol > COLUMNS - 1) { 342 destline += destcol / COLUMNS; 343 destcol %= COLUMNS; 344 } 345 if (outcol > COLUMNS - 1) { 346 l = (outcol + 1) / COLUMNS; 347 outline += l; 348 outcol %= COLUMNS; 349 if (AM == 0) { 350 while (l > 0) { 351 if (pfast) 352 if (xCR) 353 tputs(xCR, 0, putch); 354 else 355 putch('\r'); 356 if (xNL) 357 tputs(xNL, 0, putch); 358 else 359 putch('\n'); 360 l--; 361 } 362 outcol = 0; 363 } 364 if (outline > LINES - 1) { 365 destline -= outline - (LINES - 1); 366 outline = LINES - 1; 367 } 368 } 369 if (destline > LINES - 1) { 370 l = destline; 371 destline = LINES - 1; 372 if (outline < LINES - 1) { 373 c = destcol; 374 if (pfast == 0 && (!CA || holdcm)) 375 destcol = 0; 376 fgoto(); 377 destcol = c; 378 } 379 while (l > LINES - 1) { 380 /* 381 * The following linefeed (or simulation thereof) 382 * is supposed to scroll up the screen, since we 383 * are on the bottom line. We make the assumption 384 * that linefeed will scroll. If ns is in the 385 * capability list this won't work. We should 386 * probably have an sc capability but sf will 387 * generally take the place if it works. 388 * 389 * Superbee glitch: in the middle of the screen we 390 * have to use esc B (down) because linefeed screws up 391 * in "Efficient Paging" (what a joke) mode (which is 392 * essential in some SB's because CRLF mode puts garbage 393 * in at end of memory), but you must use linefeed to 394 * scroll since down arrow won't go past memory end. 395 * I turned this off after recieving Paul Eggert's 396 * Superbee description which wins better. 397 */ 398 if (xNL /* && !XB */ && pfast) 399 tputs(xNL, 0, putch); 400 else 401 putch('\n'); 402 l--; 403 if (pfast == 0) 404 outcol = 0; 405 } 406 } 407 if (destline < outline && !(CA && !holdcm || UP != NOSTR)) 408 destline = outline; 409 if (CA && !holdcm) 410 if (plod(costCM) > 0) 411 plod(0); 412 else 413 tputs(tgoto(CM, destcol, destline), 0, putch); 414 else 415 plod(0); 416 outline = destline; 417 outcol = destcol; 418 } 419 420 /* 421 * Tab to column col by flushing and then setting destcol. 422 * Used by "set all". 423 */ 424 tab(col) 425 int col; 426 { 427 428 flush1(); 429 destcol = col; 430 } 431 432 /* 433 * Move (slowly) to destination. 434 * Hard thing here is using home cursor on really deficient terminals. 435 * Otherwise just use cursor motions, hacking use of tabs and overtabbing 436 * and backspace. 437 */ 438 439 static int plodcnt, plodflg; 440 441 plodput(c) 442 { 443 444 if (plodflg) 445 plodcnt--; 446 else 447 putch(c); 448 } 449 450 plod(cnt) 451 { 452 register int i, j, k; 453 register int soutcol, soutline; 454 455 plodcnt = plodflg = cnt; 456 soutcol = outcol; 457 soutline = outline; 458 /* 459 * Consider homing and moving down/right from there, vs moving 460 * directly with local motions to the right spot. 461 */ 462 if (HO) { 463 /* 464 * i is the cost to home and tab/space to the right to 465 * get to the proper column. This assumes ND space costs 466 * 1 char. So i+destcol is cost of motion with home. 467 */ 468 if (GT) 469 i = (destcol / value(HARDTABS)) + (destcol % value(HARDTABS)); 470 else 471 i = destcol; 472 /* 473 * j is cost to move locally without homing 474 */ 475 if (destcol >= outcol) { /* if motion is to the right */ 476 j = destcol / value(HARDTABS) - outcol / value(HARDTABS); 477 if (GT && j) 478 j += destcol % value(HARDTABS); 479 else 480 j = destcol - outcol; 481 } else 482 /* leftward motion only works if we can backspace. */ 483 if (outcol - destcol <= i && (BS || BC)) 484 i = j = outcol - destcol; /* cheaper to backspace */ 485 else 486 j = i + 1; /* impossibly expensive */ 487 488 /* k is the absolute value of vertical distance */ 489 k = outline - destline; 490 if (k < 0) 491 k = -k; 492 j += k; 493 494 /* 495 * Decision. We may not have a choice if no UP. 496 */ 497 if (i + destline < j || (!UP && destline < outline)) { 498 /* 499 * Cheaper to home. Do it now and pretend it's a 500 * regular local motion. 501 */ 502 tputs(HO, 0, plodput); 503 outcol = outline = 0; 504 } else if (LL) { 505 /* 506 * Quickly consider homing down and moving from there. 507 * Assume cost of LL is 2. 508 */ 509 k = (LINES - 1) - destline; 510 if (i + k + 2 < j && (k<=0 || UP)) { 511 tputs(LL, 0, plodput); 512 outcol = 0; 513 outline = LINES - 1; 514 } 515 } 516 } else 517 /* 518 * No home and no up means it's impossible, so we return an 519 * incredibly big number to make cursor motion win out. 520 */ 521 if (!UP && destline < outline) 522 return (500); 523 if (GT) 524 i = destcol % value(HARDTABS) 525 + destcol / value(HARDTABS); 526 else 527 i = destcol; 528 /* 529 if (BT && outcol > destcol && (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) { 530 j *= (k = strlen(BT)); 531 if ((k += (destcol&7)) > 4) 532 j += 8 - (destcol&7); 533 else 534 j += k; 535 } else 536 */ 537 j = outcol - destcol; 538 /* 539 * If we will later need a \n which will turn into a \r\n by 540 * the system or the terminal, then don't bother to try to \r. 541 */ 542 if ((NONL || !pfast) && outline < destline) 543 goto dontcr; 544 /* 545 * If the terminal will do a \r\n and there isn't room for it, 546 * then we can't afford a \r. 547 */ 548 if (NC && outline >= destline) 549 goto dontcr; 550 /* 551 * If it will be cheaper, or if we can't back up, then send 552 * a return preliminarily. 553 */ 554 if (j > i + 1 || outcol > destcol && !BS && !BC) { 555 /* 556 * BUG: this doesn't take the (possibly long) length 557 * of xCR into account. 558 */ 559 if (xCR) 560 tputs(xCR, 0, plodput); 561 else 562 plodput('\r'); 563 if (NC) { 564 if (xNL) 565 tputs(xNL, 0, plodput); 566 else 567 plodput('\n'); 568 outline++; 569 } 570 outcol = 0; 571 } 572 dontcr: 573 /* Move down, if necessary, until we are at the desired line */ 574 while (outline < destline) { 575 j = destline - outline; 576 if (j > costDP && DOWN_PARM) { 577 /* Win big on Tek 4025 */ 578 tputs(tgoto(DOWN_PARM, 0, j), j, plodput); 579 outline += j; 580 } 581 else { 582 outline++; 583 if (xNL && pfast) 584 tputs(xNL, 0, plodput); 585 else 586 plodput('\n'); 587 } 588 if (plodcnt < 0) 589 goto out; 590 if (NONL || pfast == 0) 591 outcol = 0; 592 } 593 if (BT) 594 k = strlen(BT); /* should probably be cost(BT) and moved out */ 595 /* Move left, if necessary, to desired column */ 596 while (outcol > destcol) { 597 if (plodcnt < 0) 598 goto out; 599 if (BT && !insmode && outcol - destcol > 4+k) { 600 tputs(BT, 0, plodput); 601 outcol--; 602 outcol -= outcol % value(HARDTABS); /* outcol &= ~7; */ 603 continue; 604 } 605 j = outcol - destcol; 606 if (j > costLP && LEFT_PARM) { 607 tputs(tgoto(LEFT_PARM, 0, j), j, plodput); 608 outcol -= j; 609 } 610 else { 611 outcol--; 612 if (BC) 613 tputs(BC, 0, plodput); 614 else 615 plodput('\b'); 616 } 617 } 618 /* Move up, if necessary, to desired row */ 619 while (outline > destline) { 620 j = outline - destline; 621 if (UP_PARM && j > 1) { 622 /* Win big on Tek 4025 */ 623 tputs(tgoto(UP_PARM, 0, j), j, plodput); 624 outline -= j; 625 } 626 else { 627 outline--; 628 tputs(UP, 0, plodput); 629 } 630 if (plodcnt < 0) 631 goto out; 632 } 633 /* 634 * Now move to the right, if necessary. We first tab to 635 * as close as we can get. 636 */ 637 if (GT && !insmode && destcol - outcol > 1) { 638 /* tab to right as far as possible without passing col */ 639 for (;;) { 640 i = tabcol(outcol, value(HARDTABS)); 641 if (i > destcol) 642 break; 643 if (TA) 644 tputs(TA, 0, plodput); 645 else 646 plodput('\t'); 647 outcol = i; 648 } 649 /* consider another tab and then some backspaces */ 650 if (destcol - outcol > 4 && i < COLUMNS && (BC || BS)) { 651 if (TA) 652 tputs(TA, 0, plodput); 653 else 654 plodput('\t'); 655 outcol = i; 656 /* 657 * Back up. Don't worry about LEFT_PARM because 658 * it's never more than 4 spaces anyway. 659 */ 660 while (outcol > destcol) { 661 outcol--; 662 if (BC) 663 tputs(BC, 0, plodput); 664 else 665 plodput('\b'); 666 } 667 } 668 } 669 /* 670 * We've tabbed as much as possible. If we still need to go 671 * further (not exact or can't tab) space over. This is a 672 * very common case when moving to the right with space. 673 */ 674 while (outcol < destcol) { 675 j = destcol - outcol; 676 if (j > costRP && RIGHT_PARM) { 677 /* 678 * This probably happens rarely, if at all. 679 * It seems mainly useful for ANSI terminals 680 * with no hardware tabs, and I don't know 681 * of any such terminal at the moment. 682 */ 683 tputs(tgoto(RIGHT_PARM, 0, j), j, plodput); 684 outcol += j; 685 } 686 else { 687 /* 688 * move one char to the right. We don't use ND space 689 * because it's better to just print the char we are 690 * moving over. There are various exceptions, however. 691 * If !inopen, vtube contains garbage. If the char is 692 * a null or a tab we want to print a space. Other 693 * random chars we use space for instead, too. 694 */ 695 if (!inopen || vtube[outline]==NULL || 696 (i=vtube[outline][outcol]) < ' ') 697 i = ' '; 698 if(i & QUOTE) /* mjm: no sign extension on 3B */ 699 i = ' '; 700 if (insmode && ND) 701 tputs(ND, 0, plodput); 702 else 703 plodput(i); 704 outcol++; 705 } 706 if (plodcnt < 0) 707 goto out; 708 } 709 out: 710 if (plodflg) { 711 outcol = soutcol; 712 outline = soutline; 713 } 714 return(plodcnt); 715 } 716 717 /* 718 * An input line arrived. 719 * Calculate new (approximate) screen line position. 720 * Approximate because kill character echoes newline with 721 * no feedback and also because of long input lines. 722 */ 723 noteinp() 724 { 725 726 outline++; 727 if (outline > LINES - 1) 728 outline = LINES - 1; 729 destline = outline; 730 destcol = outcol = 0; 731 } 732 733 /* 734 * Something weird just happened and we 735 * lost track of whats happening out there. 736 * Since we cant, in general, read where we are 737 * we just reset to some known state. 738 * On cursor addressible terminals setting to unknown 739 * will force a cursor address soon. 740 */ 741 termreset() 742 { 743 744 endim(); 745 if (TI) /* otherwise it flushes anyway, and 'set tty=dumb' vomits */ 746 putpad(TI); /*adb change -- emit terminal initial sequence */ 747 destcol = 0; 748 destline = LINES - 1; 749 if (CA) { 750 outcol = UKCOL; 751 outline = UKCOL; 752 } else { 753 outcol = destcol; 754 outline = destline; 755 } 756 } 757 758 /* 759 * Low level buffering, with the ability to drain 760 * buffered output without printing it. 761 */ 762 char *obp = obuf; 763 764 draino() 765 { 766 767 obp = obuf; 768 } 769 770 flusho() 771 { 772 773 if (obp != obuf) { 774 #ifndef vms 775 write(1, obuf, obp - obuf); 776 #else 777 vms_write(1, obuf, obp - obuf); 778 #endif 779 obp = obuf; 780 } 781 } 782 783 putnl() 784 { 785 786 ex_putchar('\n'); 787 } 788 789 ex_putS(cp) 790 char *cp; 791 { 792 793 if (cp == NULL) 794 return; 795 while (*cp) 796 putch(*cp++); 797 } 798 799 800 putch(c) 801 int c; 802 { 803 804 #ifdef OLD3BTTY /* mjm */ 805 if(c == '\n') /* mjm: Fake "\n\r" for '\n' til fix in 3B firmware */ 806 putch('\r'); /* mjm: vi does "stty -icanon" => -onlcr !! */ 807 #endif 808 *obp++ = c & 0177; 809 if (obp >= &obuf[sizeof obuf]) 810 flusho(); 811 } 812 813 /* 814 * Miscellaneous routines related to output. 815 */ 816 817 /* 818 * Put with padding 819 */ 820 putpad(cp) 821 char *cp; 822 { 823 824 flush(); 825 tputs(cp, 0, putch); 826 } 827 828 /* 829 * Set output through normal command mode routine. 830 */ 831 setoutt() 832 { 833 834 Outchar = termchar; 835 } 836 837 /* 838 * Printf (temporarily) in list mode. 839 */ 840 /*VARARGS1*/ 841 lprintf(cp, dp) 842 char *cp, *dp; 843 { 844 register int (*P)(); 845 846 P = setlist(1); 847 ex_printf(cp, dp); 848 Put_char = P; 849 } 850 851 /* 852 * Newline + flush. 853 */ 854 putNFL() 855 { 856 857 putnl(); 858 flush(); 859 } 860 861 /* 862 * Try to start -nl mode. 863 */ 864 pstart() 865 { 866 867 if (NONL) 868 return; 869 if (!value(OPTIMIZE)) 870 return; 871 if (ruptible == 0 || pfast) 872 return; 873 fgoto(); 874 flusho(); 875 pfast = 1; 876 normtty++; 877 #ifndef USG3TTY 878 tty.sg_flags = normf & ~(ECHO|XTABS|CRMOD); 879 #else 880 tty = normf; 881 tty.c_oflag &= ~(ONLCR|TAB3); 882 tty.c_lflag &= ~ECHO; 883 #endif 884 ex_sTTY(1); 885 } 886 887 /* 888 * Stop -nl mode. 889 */ 890 pstop() 891 { 892 893 if (inopen) 894 return; 895 phadnl = 0; 896 linp = linb; 897 draino(); 898 normal(normf); 899 pfast &= ~1; 900 } 901 902 /* 903 * Prep tty for open mode. 904 */ 905 ttymode 906 ostart() 907 { 908 ttymode f; 909 910 if (!intty) 911 error("Open and visual must be used interactively"); 912 ex_gTTY(1); 913 normtty++; 914 #ifndef USG3TTY 915 f = tty.sg_flags; 916 tty.sg_flags = (normf &~ (ECHO|XTABS|CRMOD)) | 917 # ifdef CBREAK 918 CBREAK; 919 # else 920 RAW; 921 # endif 922 # ifdef TIOCGETC 923 ttcharoff(); 924 # endif 925 #else 926 f = tty; 927 tty = normf; 928 tty.c_iflag &= ~ICRNL; 929 tty.c_lflag &= ~(ECHO|ICANON); 930 tty.c_oflag &= ~(TAB3|ONLCR); 931 tty.c_cc[VMIN] = 1; 932 tty.c_cc[VTIME] = 1; 933 ttcharoff(); 934 #endif 935 ex_sTTY(1); 936 tostart(); 937 pfast |= 2; 938 return (f); 939 } 940 941 /* actions associated with putting the terminal in open mode */ 942 tostart() 943 { 944 putpad(VS); 945 putpad(KS); 946 if (!value(MESG)) { 947 if (ttynbuf[0] == 0) { 948 register char *tn; 949 if ((tn=ttyname(2)) == NULL && 950 (tn=ttyname(1)) == NULL && 951 (tn=ttyname(0)) == NULL) 952 ttynbuf[0] = 1; 953 else 954 strcpy(ttynbuf, tn); 955 } 956 if (ttynbuf[0] != 1) { 957 struct stat sbuf; 958 stat(ttynbuf, &sbuf); 959 ttymesg = sbuf.st_mode & 0777; 960 chmod(ttynbuf, 961 #ifdef UCBV7 962 /* 963 * This applies to the UCB V7 Pdp-11 system with the 964 * -u write option only. 965 */ 966 0611 /* 11 = urgent only allowed */ 967 #else 968 0600 969 #endif 970 ); 971 } 972 } 973 } 974 975 /* 976 * Turn off start/stop chars if they aren't the default ^S/^Q. 977 * This is so idiots who make esc their start/stop don't lose. 978 * We always turn off quit since datamedias send ^\ for their 979 * right arrow key. 980 */ 981 #ifdef TIOCGETC 982 ttcharoff() 983 { 984 nttyc.t_quitc = '\377'; 985 if (nttyc.t_startc != CTRL('q')) 986 nttyc.t_startc = '\377'; 987 if (nttyc.t_stopc != CTRL('s')) 988 nttyc.t_stopc = '\377'; 989 # ifdef TIOCLGET 990 nlttyc.t_suspc = '\377'; /* ^Z */ 991 nlttyc.t_dsuspc = '\377'; /* ^Y */ 992 nlttyc.t_flushc = '\377'; /* ^O */ 993 nlttyc.t_lnextc = '\377'; /* ^V */ 994 # endif 995 } 996 #endif 997 998 #ifdef USG3TTY 999 ttcharoff() 1000 { 1001 tty.c_cc[VQUIT] = '\377'; 1002 # ifdef VSTART 1003 /* 1004 * The following is sample code if USG ever lets people change 1005 * their start/stop chars. As long as they can't we can't get 1006 * into trouble so we just leave them alone. 1007 */ 1008 if (tty.c_cc[VSTART] != CTRL('q')) 1009 tty.c_cc[VSTART] = '\377'; 1010 if (tty.c_cc[VSTOP] != CTRL('s')) 1011 tty.c_cc[VSTOP] = '\377'; 1012 # endif 1013 } 1014 #endif 1015 1016 /* 1017 * Stop open, restoring tty modes. 1018 */ 1019 ostop(f) 1020 ttymode f; 1021 { 1022 1023 #ifndef USG3TTY 1024 pfast = (f & CRMOD) == 0; 1025 #else 1026 pfast = (f.c_oflag & ONLCR) == 0; 1027 #endif 1028 termreset(), fgoto(), flusho(); 1029 normal(f); 1030 tostop(); 1031 } 1032 1033 /* Actions associated with putting the terminal in the right mode. */ 1034 tostop() 1035 { 1036 putpad(VE); 1037 putpad(KE); 1038 if (!value(MESG) && ttynbuf[0]>1) 1039 chmod(ttynbuf, ttymesg); 1040 } 1041 1042 #ifndef CBREAK 1043 /* 1044 * Into cooked mode for interruptibility. 1045 */ 1046 vcook() 1047 { 1048 1049 tty.sg_flags &= ~RAW; 1050 ex_sTTY(1); 1051 } 1052 1053 /* 1054 * Back into raw mode. 1055 */ 1056 vraw() 1057 { 1058 1059 tty.sg_flags |= RAW; 1060 ex_sTTY(1); 1061 } 1062 #endif 1063 1064 /* 1065 * Restore flags to normal state f. 1066 */ 1067 normal(f) 1068 ttymode f; 1069 { 1070 1071 if (normtty > 0) { 1072 ignore(setty(f)); 1073 normtty--; 1074 } 1075 } 1076 1077 /* 1078 * Straight set of flags to state f. 1079 */ 1080 ttymode 1081 setty(f) 1082 ttymode f; 1083 { 1084 #ifndef USG3TTY 1085 register int ot = tty.sg_flags; 1086 #else 1087 ttymode ot; 1088 ot = tty; 1089 #endif 1090 1091 #ifndef USG3TTY 1092 # ifdef TIOCGETC 1093 if (f == normf) { 1094 nttyc = ottyc; 1095 # ifdef TIOCLGET 1096 nlttyc = olttyc; 1097 # endif 1098 } else 1099 ttcharoff(); 1100 # endif 1101 tty.sg_flags = f; 1102 #else 1103 if (tty.c_lflag & ICANON) 1104 ttcharoff(); 1105 tty = f; 1106 #endif 1107 ex_sTTY(1); 1108 return (ot); 1109 } 1110 1111 ex_gTTY(i) 1112 int i; 1113 { 1114 1115 #ifndef USG3TTY 1116 ignore(gtty(i, &tty)); 1117 # ifdef TIOCGETC 1118 ioctl(i, TIOCGETC, (char *) &ottyc); 1119 nttyc = ottyc; 1120 # endif 1121 # ifdef TIOCGLTC 1122 ioctl(i, TIOCGLTC, (char *) &olttyc); 1123 nlttyc = olttyc; 1124 # endif 1125 #else 1126 ioctl(i, TCGETA, (char *) &tty); 1127 #endif 1128 } 1129 1130 /* 1131 * ex_sTTY: set the tty modes on file descriptor i to be what's 1132 * currently in global "tty". (Also use nttyc if needed.) 1133 */ 1134 ex_sTTY(i) 1135 int i; 1136 { 1137 1138 #ifndef USG3TTY 1139 # ifdef USG 1140 /* Bug in USG tty driver, put out a DEL as a patch. */ 1141 if (tty.sg_ospeed >= B1200) 1142 write(1, "\377", 1); 1143 # endif 1144 1145 # ifdef TIOCSETN 1146 /* Don't flush typeahead if we don't have to */ 1147 ioctl(i, TIOCSETN, (char *) &tty); 1148 # else 1149 /* We have to. Too bad. */ 1150 stty(i, &tty); 1151 # endif 1152 1153 # ifdef TIOCGETC 1154 /* Update the other random chars while we're at it. */ 1155 ioctl(i, TIOCSETC, (char *) &nttyc); 1156 # endif 1157 # ifdef TIOCSLTC 1158 ioctl(i, TIOCSLTC, (char *) &nlttyc); 1159 # endif 1160 1161 #else 1162 /* USG 3 very simple: just set everything */ 1163 ioctl(i, TCSETAW, (char *) &tty); 1164 #endif 1165 } 1166 1167 /* 1168 * Print newline, or blank if in open/visual 1169 */ 1170 noonl() 1171 { 1172 1173 ex_putchar(Outchar != termchar ? ' ' : '\n'); 1174 } 1175