2.9BSD - /usr/src/ucb/ex/ex3/ex_put.c

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

Defined functions

Defined variables