![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_put.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / ex|
Return to ex_put.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / ex |
1.1 ! root 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.9 (Berkeley) 6/7/85"; ! 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 (*Putchar)() = 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 = Putchar; ! 43: Putchar = 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: 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: 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: putchar(*cp++); ! 164: if (!inopen) ! 165: 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 (Putchar == 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: putchar(c) ! 221: int c; ! 222: { ! 223: ! 224: (*Putchar)(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: write(1, obuf, obp - obuf); ! 775: obp = obuf; ! 776: } ! 777: } ! 778: ! 779: putnl() ! 780: { ! 781: ! 782: putchar('\n'); ! 783: } ! 784: ! 785: putS(cp) ! 786: char *cp; ! 787: { ! 788: ! 789: if (cp == NULL) ! 790: return; ! 791: while (*cp) ! 792: putch(*cp++); ! 793: } ! 794: ! 795: ! 796: putch(c) ! 797: int c; ! 798: { ! 799: ! 800: #ifdef OLD3BTTY /* mjm */ ! 801: if(c == '\n') /* mjm: Fake "\n\r" for '\n' til fix in 3B firmware */ ! 802: putch('\r'); /* mjm: vi does "stty -icanon" => -onlcr !! */ ! 803: #endif ! 804: *obp++ = c & 0177; ! 805: if (obp >= &obuf[sizeof obuf]) ! 806: flusho(); ! 807: } ! 808: ! 809: /* ! 810: * Miscellaneous routines related to output. ! 811: */ ! 812: ! 813: /* ! 814: * Put with padding ! 815: */ ! 816: putpad(cp) ! 817: char *cp; ! 818: { ! 819: ! 820: flush(); ! 821: tputs(cp, 0, putch); ! 822: } ! 823: ! 824: /* ! 825: * Set output through normal command mode routine. ! 826: */ ! 827: setoutt() ! 828: { ! 829: ! 830: Outchar = termchar; ! 831: } ! 832: ! 833: /* ! 834: * Printf (temporarily) in list mode. ! 835: */ ! 836: /*VARARGS2*/ ! 837: lprintf(cp, dp) ! 838: char *cp, *dp; ! 839: { ! 840: register int (*P)(); ! 841: ! 842: P = setlist(1); ! 843: printf(cp, dp); ! 844: Putchar = P; ! 845: } ! 846: ! 847: /* ! 848: * Newline + flush. ! 849: */ ! 850: putNFL() ! 851: { ! 852: ! 853: putnl(); ! 854: flush(); ! 855: } ! 856: ! 857: /* ! 858: * Try to start -nl mode. ! 859: */ ! 860: pstart() ! 861: { ! 862: ! 863: if (NONL) ! 864: return; ! 865: if (!value(OPTIMIZE)) ! 866: return; ! 867: if (ruptible == 0 || pfast) ! 868: return; ! 869: fgoto(); ! 870: flusho(); ! 871: pfast = 1; ! 872: normtty++; ! 873: #ifndef USG3TTY ! 874: tty.sg_flags = normf & ~(ECHO|XTABS|CRMOD); ! 875: #else ! 876: tty = normf; ! 877: tty.c_oflag &= ~(ONLCR|TAB3); ! 878: tty.c_lflag &= ~ECHO; ! 879: #endif ! 880: sTTY(1); ! 881: } ! 882: ! 883: /* ! 884: * Stop -nl mode. ! 885: */ ! 886: pstop() ! 887: { ! 888: ! 889: if (inopen) ! 890: return; ! 891: phadnl = 0; ! 892: linp = linb; ! 893: draino(); ! 894: normal(normf); ! 895: pfast &= ~1; ! 896: } ! 897: ! 898: /* ! 899: * Prep tty for open mode. ! 900: */ ! 901: ttymode ! 902: ostart() ! 903: { ! 904: ttymode f; ! 905: ! 906: if (!intty) ! 907: error("Open and visual must be used interactively"); ! 908: gTTY(1); ! 909: normtty++; ! 910: #ifndef USG3TTY ! 911: f = tty.sg_flags; ! 912: tty.sg_flags = (normf &~ (ECHO|XTABS|CRMOD)) | ! 913: # ifdef CBREAK ! 914: CBREAK; ! 915: # else ! 916: RAW; ! 917: # endif ! 918: # ifdef TIOCGETC ! 919: ttcharoff(); ! 920: # endif ! 921: #else ! 922: f = tty; ! 923: tty = normf; ! 924: tty.c_iflag &= ~ICRNL; ! 925: tty.c_lflag &= ~(ECHO|ICANON); ! 926: tty.c_oflag &= ~(TAB3|ONLCR); ! 927: tty.c_cc[VMIN] = 1; ! 928: tty.c_cc[VTIME] = 1; ! 929: ttcharoff(); ! 930: #endif ! 931: sTTY(1); ! 932: tostart(); ! 933: pfast |= 2; ! 934: return (f); ! 935: } ! 936: ! 937: /* actions associated with putting the terminal in open mode */ ! 938: tostart() ! 939: { ! 940: putpad(VS); ! 941: putpad(KS); ! 942: if (!value(MESG)) { ! 943: if (ttynbuf[0] == 0) { ! 944: register char *tn; ! 945: if ((tn=ttyname(2)) == NULL && ! 946: (tn=ttyname(1)) == NULL && ! 947: (tn=ttyname(0)) == NULL) ! 948: ttynbuf[0] = 1; ! 949: else ! 950: strcpy(ttynbuf, tn); ! 951: } ! 952: if (ttynbuf[0] != 1) { ! 953: struct stat sbuf; ! 954: stat(ttynbuf, &sbuf); ! 955: ttymesg = sbuf.st_mode & 0777; ! 956: chmod(ttynbuf, ! 957: #ifdef UCBV7 ! 958: /* ! 959: * This applies to the UCB V7 Pdp-11 system with the ! 960: * -u write option only. ! 961: */ ! 962: 0611 /* 11 = urgent only allowed */ ! 963: #else ! 964: 0600 ! 965: #endif ! 966: ); ! 967: } ! 968: } ! 969: } ! 970: ! 971: /* ! 972: * Turn off start/stop chars if they aren't the default ^S/^Q. ! 973: * This is so idiots who make esc their start/stop don't lose. ! 974: * We always turn off quit since datamedias send ^\ for their ! 975: * right arrow key. ! 976: */ ! 977: #ifdef TIOCGETC ! 978: ttcharoff() ! 979: { ! 980: nttyc.t_quitc = '\377'; ! 981: if (nttyc.t_startc != CTRL(q)) ! 982: nttyc.t_startc = '\377'; ! 983: if (nttyc.t_stopc != CTRL(s)) ! 984: nttyc.t_stopc = '\377'; ! 985: # ifdef TIOCLGET ! 986: nlttyc.t_suspc = '\377'; /* ^Z */ ! 987: nlttyc.t_dsuspc = '\377'; /* ^Y */ ! 988: nlttyc.t_flushc = '\377'; /* ^O */ ! 989: nlttyc.t_lnextc = '\377'; /* ^V */ ! 990: # endif ! 991: } ! 992: #endif ! 993: ! 994: #ifdef USG3TTY ! 995: ttcharoff() ! 996: { ! 997: tty.c_cc[VQUIT] = '\377'; ! 998: # ifdef VSTART ! 999: /* ! 1000: * The following is sample code if USG ever lets people change ! 1001: * their start/stop chars. As long as they can't we can't get ! 1002: * into trouble so we just leave them alone. ! 1003: */ ! 1004: if (tty.c_cc[VSTART] != CTRL(q)) ! 1005: tty.c_cc[VSTART] = '\377'; ! 1006: if (tty.c_cc[VSTOP] != CTRL(s)) ! 1007: tty.c_cc[VSTOP] = '\377'; ! 1008: # endif ! 1009: } ! 1010: #endif ! 1011: ! 1012: /* ! 1013: * Stop open, restoring tty modes. ! 1014: */ ! 1015: ostop(f) ! 1016: ttymode f; ! 1017: { ! 1018: ! 1019: #ifndef USG3TTY ! 1020: pfast = (f & CRMOD) == 0; ! 1021: #else ! 1022: pfast = (f.c_oflag & ONLCR) == 0; ! 1023: #endif ! 1024: termreset(), fgoto(), flusho(); ! 1025: normal(f); ! 1026: tostop(); ! 1027: } ! 1028: ! 1029: /* Actions associated with putting the terminal in the right mode. */ ! 1030: tostop() ! 1031: { ! 1032: putpad(VE); ! 1033: putpad(KE); ! 1034: if (!value(MESG) && ttynbuf[0]>1) ! 1035: chmod(ttynbuf, ttymesg); ! 1036: } ! 1037: ! 1038: #ifndef CBREAK ! 1039: /* ! 1040: * Into cooked mode for interruptibility. ! 1041: */ ! 1042: vcook() ! 1043: { ! 1044: ! 1045: tty.sg_flags &= ~RAW; ! 1046: sTTY(1); ! 1047: } ! 1048: ! 1049: /* ! 1050: * Back into raw mode. ! 1051: */ ! 1052: vraw() ! 1053: { ! 1054: ! 1055: tty.sg_flags |= RAW; ! 1056: sTTY(1); ! 1057: } ! 1058: #endif ! 1059: ! 1060: /* ! 1061: * Restore flags to normal state f. ! 1062: */ ! 1063: normal(f) ! 1064: ttymode f; ! 1065: { ! 1066: ! 1067: if (normtty > 0) { ! 1068: setty(f); ! 1069: normtty--; ! 1070: } ! 1071: } ! 1072: ! 1073: /* ! 1074: * Straight set of flags to state f. ! 1075: */ ! 1076: ttymode ! 1077: setty(f) ! 1078: ttymode f; ! 1079: { ! 1080: #ifndef USG3TTY ! 1081: register int ot = tty.sg_flags; ! 1082: #else ! 1083: ttymode ot; ! 1084: ot = tty; ! 1085: #endif ! 1086: ! 1087: #ifndef USG3TTY ! 1088: if (f == normf) { ! 1089: nttyc = ottyc; ! 1090: # ifdef TIOCLGET ! 1091: nlttyc = olttyc; ! 1092: # endif ! 1093: } else ! 1094: ttcharoff(); ! 1095: tty.sg_flags = f; ! 1096: #else ! 1097: if (tty.c_lflag & ICANON) ! 1098: ttcharoff(); ! 1099: tty = f; ! 1100: #endif ! 1101: sTTY(1); ! 1102: return (ot); ! 1103: } ! 1104: ! 1105: gTTY(i) ! 1106: int i; ! 1107: { ! 1108: ! 1109: #ifndef USG3TTY ! 1110: ignore(gtty(i, &tty)); ! 1111: # ifdef TIOCGETC ! 1112: ioctl(i, TIOCGETC, &ottyc); ! 1113: nttyc = ottyc; ! 1114: # endif ! 1115: # ifdef TIOCGLTC ! 1116: ioctl(i, TIOCGLTC, &olttyc); ! 1117: nlttyc = olttyc; ! 1118: # endif ! 1119: #else ! 1120: ioctl(i, TCGETA, &tty); ! 1121: #endif ! 1122: } ! 1123: ! 1124: /* ! 1125: * sTTY: set the tty modes on file descriptor i to be what's ! 1126: * currently in global "tty". (Also use nttyc if needed.) ! 1127: */ ! 1128: sTTY(i) ! 1129: int i; ! 1130: { ! 1131: ! 1132: #ifndef USG3TTY ! 1133: # ifdef USG ! 1134: /* Bug in USG tty driver, put out a DEL as a patch. */ ! 1135: if (tty.sg_ospeed >= B1200) ! 1136: write(1, "\377", 1); ! 1137: # endif ! 1138: ! 1139: # ifdef TIOCSETN ! 1140: /* Don't flush typeahead if we don't have to */ ! 1141: ioctl(i, TIOCSETN, &tty); ! 1142: # else ! 1143: /* We have to. Too bad. */ ! 1144: stty(i, &tty); ! 1145: # endif ! 1146: ! 1147: # ifdef TIOCGETC ! 1148: /* Update the other random chars while we're at it. */ ! 1149: ioctl(i, TIOCSETC, &nttyc); ! 1150: # endif ! 1151: # ifdef TIOCSLTC ! 1152: ioctl(i, TIOCSLTC, &nlttyc); ! 1153: # endif ! 1154: ! 1155: #else ! 1156: /* USG 3 very simple: just set everything */ ! 1157: ioctl(i, TCSETAW, &tty); ! 1158: #endif ! 1159: } ! 1160: ! 1161: /* ! 1162: * Print newline, or blank if in open/visual ! 1163: */ ! 1164: noonl() ! 1165: { ! 1166: ! 1167: putchar(Outchar != termchar ? ' ' : '\n'); ! 1168: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.