usr/src/cmd/tput/tput.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  * Copyright (c) 2012 Gary Mills
  26  */
  27
  28 /*      Copyright (c) 1988 AT&T */
  29 /*        All Rights Reserved   */
  30
  31 /*
  32  *      tput - print terminal attribute
  33  *
  34  *  return-codes - command line arguments:
  35  *      0: ok if boolean capname -> TRUE
  36  *      1: for boolean capname -> FALSE
  37  *
  38  *  return-codes - standard input arguments:
  39  *      0: ok; tput for all lines was successful
  40  *
  41  *  return-codes - both cases:
  42  *      2       usage error
  43  *      3       bad terminal type given or no terminfo database
  44  *      4       unknown capname
  45  *      -1      capname is a numeric variable that is not specified in the
  46  *              terminfo database(E.g. tpu -T450 lines).
  47  *
  48  *  tput printfs a value if an INT capname was given; e.g. cols.
  49  *      putp's a string if a STRING capname was given; e.g. clear. and
  50  *  for BOOLEAN capnames, e.g. hard-copy, just returns the boolean value.
  51  */
  52
  53 #include <curses.h>
  54 #include <term.h>
  55 #include <fcntl.h>
  56 #include <ctype.h>
  57 #include <stdlib.h>
  58 #include <string.h>
  59 #include <sys/types.h>
  60 #include <unistd.h>
  61 #include <locale.h>
  62
  63 /* externs from libcurses */
  64 extern int tigetnum();
  65
  66 static int outputcap(char *cap, int argc, char **argv);
  67 static int allnumeric(char *string);
  68 static int getpad(char *cap);
  69 static void setdelay();
  70 static void settabs();
  71 static void cat(char *file);
  72 static void initterm();
  73 static void reset_term();
  74
  75 static char *progname;          /* argv[0] */
  76 static int CurrentBaudRate;     /* current baud rate */
  77 static int reset = 0;           /* called as reset_term */
  78 static int fildes = 1;
  79
  80 int
  81 main(int argc, char **argv)
  82 {
  83         int i, std_argc;
  84         char *term = getenv("TERM");
  85         char *cap, std_input = FALSE;
  86         int setuperr;
  87
  88         (void) setlocale(LC_ALL, "");
  89 #if !defined(TEXT_DOMAIN)
  90 #define TEXT_DOMAIN "SYS_TEST"
  91 #endif
  92         (void) textdomain(TEXT_DOMAIN);
  93
  94         progname = argv[0];
  95
  96         while ((i = getopt(argc, argv, "ST:")) != EOF) {
  97                 switch (i) {
  98                 case 'T':
  99                         fildes = -1;
 100                         (void) putenv("LINES=");
 101                         (void) putenv("COLUMNS=");
 102                         term = optarg;
 103                         break;
 104
 105                 case 'S':
 106                         std_input = TRUE;
 107                         break;
 108
 109                 case '?':                       /* FALLTHROUGH          */
 110                 usage:                          /* FALLTHROUGH          */
 111                 default:
 112                         (void) fprintf(stderr, gettext(
 113                             "usage:\t%s [-T [term]] capname "
 114                             "[parm argument...]\n"), progname);
 115                         (void) fprintf(stderr, gettext("OR:\t%s -S <<\n"),
 116                             progname);
 117                         exit(2);
 118                 }
 119         }
 120
 121         if (!term || !*term) {
 122                 (void) fprintf(stderr,
 123                     gettext("%s: No value for $TERM and no -T specified\n"),
 124                     progname);
 125                 exit(2);
 126         }
 127
 128         (void) setupterm(term, fildes, &setuperr);
 129
 130         switch (setuperr) {
 131         case -2:
 132                 (void) fprintf(stderr,
 133                     gettext("%s: unreadable terminal descriptor \"%s\"\n"),
 134                     progname, term);
 135                 exit(3);
 136                 break;
 137
 138         case -1:
 139                 (void) fprintf(stderr,
 140                     gettext("%s: no terminfo database\n"), progname);
 141                 exit(3);
 142                 break;
 143
 144         case 0:
 145                 (void) fprintf(stderr,
 146                     gettext("%s: unknown terminal \"%s\"\n"),
 147                     progname, term);
 148                 exit(3);
 149         }
 150
 151         reset_shell_mode();
 152
 153         /* command line arguments */
 154         if (!std_input) {
 155                 if (argc == optind)
 156                         goto usage;
 157
 158                 cap = argv[optind++];
 159
 160                 if (strcmp(cap, "init") == 0)
 161                         initterm();
 162                 else if (strcmp(cap, "reset") == 0)
 163                         reset_term();
 164                 else if (strcmp(cap, "longname") == 0)
 165                         (void) printf("%s\n", longname());
 166                 else
 167                         exit(outputcap(cap, argc, argv));
 168                 return (0);
 169         } else {                        /* standard input argumets      */
 170                 char buff[128];
 171                 char **v;
 172
 173                 /* allocate storage for the 'faked' argv[] array        */
 174                 v = (char **)malloc(10 * sizeof (char *));
 175                 for (i = 0; i < 10; i++)
 176                         v[i] = (char *)malloc(32 * sizeof (char));
 177
 178                 while (fgets(buff, sizeof (buff), stdin) != NULL) {
 179                         /* read standard input line; skip over empty lines */
 180                         if ((std_argc =
 181                             sscanf(buff,
 182                             "%31s %31s %31s %31s %31s %31s %31s %31s "
 183                             "%31s %31s",
 184                             v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7],
 185                             v[8], v[9])) < 1) {
 186                                 continue;
 187                         }
 188
 189                         cap = v[0];
 190                         optind = 1;
 191
 192                         if (strcmp(cap, "init") == 0) {
 193                                 initterm();
 194                         } else if (strcmp(cap, "reset") == 0) {
 195                                 reset_term();
 196                         } else if (strcmp(cap, "longname") == 0) {
 197                                 (void) printf("%s\n", longname());
 198                         } else {
 199                                 (void) outputcap(cap, std_argc, v);
 200                         }
 201                         (void) fflush(stdout);
 202                 }
 203
 204                 return (0);
 205         }
 206 }
 207
 208 static long parm[9] = {
 209     0, 0, 0, 0, 0, 0, 0, 0, 0
 210 };
 211
 212 static int
 213 outputcap(char *cap, int argc, char **argv)
 214 {
 215         int parmset = 0;
 216         char *thisstr;
 217         int i;
 218
 219         if ((i = tigetflag(cap)) >= 0)
 220                 return (1 - i);
 221
 222         if ((i = tigetnum(cap)) >= -1) {
 223                 (void) printf("%d\n", i);
 224                 return (0);
 225         }
 226
 227         if ((thisstr = tigetstr(cap)) != (char *)-1) {
 228                 if (!thisstr) {
 229                         return (1);
 230                 }
 231                 for (parmset = 0; optind < argc; optind++, parmset++)
 232                         if (allnumeric(argv[optind]))
 233                                 parm[parmset] = atoi(argv[optind]);
 234                         else
 235                                 parm[parmset] = (int)argv[optind];
 236
 237                 if (parmset)
 238                         putp(tparm(thisstr,
 239                             parm[0], parm[1], parm[2], parm[3],
 240                             parm[4], parm[5], parm[6], parm[7], parm[8]));
 241                 else
 242                         putp(thisstr);
 243                 return (0);
 244         }
 245
 246         (void) fprintf(stderr,
 247             gettext("%s: unknown terminfo capability '%s'\n"), progname, cap);
 248
 249         exit(4);
 250         /* NOTREACHED */
 251 }
 252
 253 /*
 254  *  The decision as to whether an argument is a number or not is to simply
 255  *  look at whether there are any non-digits in the string.
 256  */
 257 static int
 258 allnumeric(char *string)
 259 {
 260         if (*string) {
 261                 while (*string) {
 262                         if (!isdigit(*string++)) {
 263                                 return (0);
 264                         }
 265                 }
 266                 return (1);
 267         } else {
 268                 return (0);
 269         }
 270 }
 271
 272 /*
 273  *  SYSTEM DEPENDENT TERMINAL DELAY TABLES
 274  *
 275  *      These tables maintain the correspondence between the delays
 276  *      defined in terminfo and the delay algorithms in the tty driver
 277  *      on the particular systems. For each type of delay, the bits used
 278  *      for that delay must be specified, in XXbits, and a table
 279  *      must be defined giving correspondences between delays and
 280  *      algorithms. Algorithms which are not fixed delays, such
 281  *      as dependent on current column or line number, must be
 282  *      kludged in some way at this time.
 283  *
 284  *      Some of this was taken from tset(1).
 285  */
 286
 287 struct delay
 288 {
 289     int d_delay;
 290     int d_bits;
 291 };
 292
 293 /* The appropriate speeds for various termio settings. */
 294 static int speeds[] = {
 295                 0,      /*  B0,         */
 296                 50,     /*  B50,        */
 297                 75,     /*  B75,        */
 298                 110,    /*  B110,       */
 299                 134,    /*  B134,       */
 300                 150,    /*  B150,       */
 301                 200,    /*  B200,       */
 302                 300,    /*  B300,       */
 303                 600,    /*  B600,       */
 304                 1200,   /*  B1200,      */
 305                 1800,   /*  B1800,      */
 306                 2400,   /*  B2400,      */
 307                 4800,   /*  B4800,      */
 308                 9600,   /*  B9600,      */
 309                 19200,  /*  EXTA,       */
 310                 38400,  /*  EXTB,       */
 311                 57600,  /*  B57600,     */
 312                 76800,  /*  B76800,     */
 313                 115200, /*  B115200,    */
 314                 153600, /*  B153600,    */
 315                 230400, /*  B230400,    */
 316                 307200, /*  B307200,    */
 317                 460800, /*  B460800,    */
 318                 921600, /*  B921600,    */
 319                 0,
 320 };
 321
 322 #if defined(SYSV) || defined(USG)
 323 /*      Unix 3.0 on up */
 324
 325 /*    Carriage Return delays    */
 326
 327 static int      CRbits = CRDLY;
 328 static struct delay     CRdelay[] =
 329 {
 330         0,      CR0,
 331         80,     CR1,
 332         100,    CR2,
 333         150,    CR3,
 334         -1
 335 };
 336
 337 /*      New Line delays */
 338
 339 static int      NLbits = NLDLY;
 340 static struct delay     NLdelay[] =
 341 {
 342         0,      NL0,
 343         100,    NL1,
 344         -1
 345 };
 346
 347 /*      Back Space delays       */
 348
 349 static int      BSbits = BSDLY;
 350 static struct delay     BSdelay[] =
 351 {
 352         0,      BS0,
 353         50,     BS1,
 354         -1
 355 };
 356
 357 /*      TaB delays      */
 358
 359 static int      TBbits = TABDLY;
 360 static struct delay     TBdelay[] =
 361 {
 362         0,      TAB0,
 363         11,     TAB1,           /* special M37 delay */
 364         100,    TAB2,
 365                                 /* TAB3 is XTABS and not a delay */
 366         -1
 367 };
 368
 369 /*      Form Feed delays        */
 370
 371 static int      FFbits = FFDLY;
 372 static struct delay     FFdelay[] =
 373 {
 374         0,      FF0,
 375         2000,   FF1,
 376         -1
 377 };
 378
 379 #else   /* BSD */
 380
 381 /*      Carriage Return delays  */
 382
 383 int     CRbits = CRDELAY;
 384 struct delay    CRdelay[] =
 385 {
 386         0,      CR0,
 387         9,      CR3,
 388         80,     CR1,
 389         160,    CR2,
 390         -1
 391 };
 392
 393 /*      New Line delays */
 394
 395 int     NLbits = NLDELAY;
 396 struct delay    NLdelay[] =
 397 {
 398         0,      NL0,
 399         66,     NL1,            /* special M37 delay */
 400         100,    NL2,
 401         -1
 402 };
 403
 404 /*      Tab delays      */
 405
 406 int     TBbits = TBDELAY;
 407 struct delay    TBdelay[] =
 408 {
 409         0,      TAB0,
 410         11,     TAB1,           /* special M37 delay */
 411         -1
 412 };
 413
 414 /*      Form Feed delays        */
 415
 416 int     FFbits = VTDELAY;
 417 struct delay    FFdelay[] =
 418 {
 419         0,      FF0,
 420         2000,   FF1,
 421         -1
 422 };
 423 #endif  /* BSD */
 424
 425 /*
 426  *  Initterm, a.k.a. reset_term, does terminal specific initialization. In
 427  *  particular, the init_strings from terminfo are output and tabs are
 428  *  set, if they aren't hardwired in. Much of this stuff was done by
 429  *  the tset(1) program.
 430  */
 431
 432 /*
 433  *  Figure out how many milliseconds of padding the capability cap
 434  *  needs and return that number. Padding is stored in the string as "$<n>",
 435  *  where n is the number of milliseconds of padding. More than one
 436  *  padding string is allowed within the string, although this is unlikely.
 437  */
 438
 439 static int
 440 getpad(char *cap)
 441 {
 442         int padding = 0;
 443
 444         /* No padding needed at speeds below padding_baud_rate */
 445         if (padding_baud_rate > CurrentBaudRate || cap == NULL)
 446                 return (0);
 447
 448         while (*cap) {
 449                 if ((cap[0] == '$') && (cap[1] == '<')) {
 450                         cap++;
 451                         cap++;
 452                         padding += atoi(cap);
 453                         while (isdigit (*cap))
 454                                 cap++;
 455                         while (*cap == '.' || *cap == '/' || *cap == '*' ||
 456                             isdigit(*cap))
 457                                 cap++;
 458                         while (*cap == '>')
 459                                 cap++;
 460                 } else {
 461                         cap++;
 462                 }
 463         }
 464
 465         return (padding);
 466 }
 467
 468 /*
 469  *  Set the appropriate delay bits in the termio structure for
 470  *  the given delay.
 471  */
 472 static void
 473 setdelay(delay, delaytable, bits, flags)
 474 register int delay;
 475 struct delay delaytable[];
 476 int bits;
 477 #ifdef SYSV
 478 tcflag_t *flags;
 479 #else   /* SYSV */
 480 unsigned short *flags;
 481 #endif  /* SYSV */
 482 {
 483         register struct delay  *p;
 484         register struct delay  *lastdelay;
 485
 486         /* Clear out the bits, replace with new ones */
 487         *flags &= ~bits;
 488
 489         /* Scan the delay table for first entry with adequate delay */
 490         for (lastdelay = p = delaytable;
 491             (p -> d_delay >= 0) && (p -> d_delay < delay);
 492             p++) {
 493                 lastdelay = p;
 494         }
 495
 496         /* use last entry if none will do */
 497         *flags |= lastdelay -> d_bits;
 498 }
 499
 500 /*
 501  * Set the hardware tabs on the terminal, using clear_all_tabs,
 502  * set_tab, and column_address capabilities. Cursor_address and cursor_right
 503  * may also be used, if necessary.
 504  * This is done before the init_file and init_3string, so they can patch in
 505  * case we blow this.
 506  */
 507
 508 static void
 509 settabs()
 510 {
 511         register int c;
 512
 513         /* Do not set tabs if they power up properly. */
 514         if (init_tabs == 8)
 515                 return;
 516
 517         if (set_tab) {
 518                 /* Force the cursor to be at the left margin. */
 519                 if (carriage_return)
 520                         putp(carriage_return);
 521                 else
 522                         (void) putchar('\r');
 523
 524                 /* Clear any current tab settings. */
 525                 if (clear_all_tabs)
 526                         putp(clear_all_tabs);
 527
 528                 /* Set the tabs. */
 529                 for (c = 8; c < columns; c += 8) {
 530                         /* Get to that column. */
 531                         (void) fputs("        ", stdout);
 532
 533                         /* Set the tab. */
 534                         putp(set_tab);
 535                 }
 536
 537                 /* Get back to the left column. */
 538                 if (carriage_return)
 539                         putp(carriage_return);
 540                 else
 541                         (void) putchar('\r');
 542
 543         }
 544 }
 545
 546 /*
 547  *  Copy "file" onto standard output.
 548  */
 549
 550 static void
 551 cat(file)
 552 char *file;                             /* File to copy. */
 553 {
 554         register int fd;                        /* File descriptor. */
 555         register ssize_t i;                     /* Number characters read. */
 556         char buf[BUFSIZ];                       /* Buffer to read into. */
 557
 558         fd = open(file, O_RDONLY);
 559
 560         if (fd < 0) {
 561                 perror("Cannot open initialization file");
 562         } else {
 563                 while ((i = read(fd, buf, BUFSIZ)) > (ssize_t)0)
 564                         (void) write(fileno(stdout), buf, (unsigned)i);
 565                 (int)close(fd);
 566         }
 567 }
 568
 569 /*
 570  *  Initialize the terminal.
 571  *  Send the initialization strings to the terminal.
 572  */
 573
 574 static void
 575 initterm()
 576 {
 577         register int filedes;           /* File descriptor for ioctl's. */
 578 #if defined(SYSV) || defined(USG)
 579         struct termio termmode;         /* To hold terminal settings. */
 580         struct termios termmodes;       /* To hold terminal settings. */
 581         int i;
 582         int istermios = -1;
 583 #define GTTY(fd, mode)  ioctl(fd, TCGETA, mode)
 584 #define GTTYS(fd, mode) \
 585         (istermios = ioctl(fd, TCGETS, mode))
 586 #define STTY(fd, mode)  ioctl(fd, TCSETAW, mode)
 587 #define STTYS(fd, mode) ioctl(fd, TCSETSW, mode)
 588 #define SPEED(mode)     (mode.c_cflag & CBAUD)
 589 #define SPEEDS(mode)    (cfgetospeed(&mode))
 590 #define OFLAG(mode)     mode.c_oflag
 591 #else   /* BSD */
 592         struct sgttyb termmode;         /* To hold terminal settings. */
 593 #define GTTY(fd, mode)  gtty(fd, mode)
 594 #define STTY(fd, mode)  stty(fd, mode)
 595 #define SPEED(mode)     (mode.sg_ospeed & 017)
 596 #define OFLAG(mode)     mode.sg_flags
 597 #define TAB3            XTABS
 598 #endif
 599
 600         /* Get the terminal settings. */
 601         /* First try standard output, then standard error, */
 602         /* then standard input, then /dev/tty. */
 603 #ifdef SYSV
 604         if ((filedes = 1, GTTYS(filedes, &termmodes) < 0) ||
 605             (filedes = 2, GTTYS(filedes, &termmodes) < 0) ||
 606             (filedes = 0, GTTYS(filedes, &termmodes) < 0) ||
 607             (filedes = open("/dev/tty", O_RDWR),
 608             GTTYS(filedes, &termmodes) < 0)) {
 609 #endif  /* SYSV */
 610                 if ((filedes = 1, GTTY(filedes, &termmode) == -1) ||
 611                     (filedes = 2, GTTY(filedes, &termmode) == -1) ||
 612                     (filedes = 0, GTTY(filedes, &termmode) == -1) ||
 613                     (filedes = open("/dev/tty", O_RDWR),
 614                     GTTY(filedes, &termmode) == -1)) {
 615                         filedes = -1;
 616                         CurrentBaudRate = speeds[B1200];
 617                 } else
 618                         CurrentBaudRate = speeds[SPEED(termmode)];
 619 #ifdef SYSV
 620                 termmodes.c_lflag = termmode.c_lflag;
 621                 termmodes.c_oflag = termmode.c_oflag;
 622                 termmodes.c_iflag = termmode.c_iflag;
 623                 termmodes.c_cflag = termmode.c_cflag;
 624                 for (i = 0; i < NCC; i++)
 625                         termmodes.c_cc[i] = termmode.c_cc[i];
 626         } else
 627                 CurrentBaudRate = speeds[SPEEDS(termmodes)];
 628 #endif  /* SYSV */
 629
 630         if (xon_xoff) {
 631 #ifdef SYSV
 632                 OFLAG(termmodes) &=
 633                     ~(NLbits | CRbits | BSbits | FFbits | TBbits);
 634 #else   /* SYSV */
 635                 OFLAG(termmode) &=
 636                     ~(NLbits | CRbits | BSbits | FFbits | TBbits);
 637 #endif  /* SYSV */
 638         } else {
 639 #ifdef SYSV
 640                 setdelay(getpad(carriage_return),
 641                     CRdelay, CRbits, &OFLAG(termmodes));
 642                 setdelay(getpad(scroll_forward),
 643                     NLdelay, NLbits, &OFLAG(termmodes));
 644                 setdelay(getpad(cursor_left),
 645                     BSdelay, BSbits, &OFLAG(termmodes));
 646                 setdelay(getpad(form_feed),
 647                     FFdelay, FFbits, &OFLAG(termmodes));
 648                 setdelay(getpad(tab),
 649                     TBdelay, TBbits, &OFLAG(termmodes));
 650 #else   /* SYSV */
 651                 setdelay(getpad(carriage_return),
 652                     CRdelay, CRbits, &OFLAG(termmode));
 653                 setdelay(getpad(scroll_forward),
 654                     NLdelay, NLbits, &OFLAG(termmode));
 655                 setdelay(getpad(cursor_left),
 656                     BSdelay, BSbits, &OFLAG(termmode));
 657                 setdelay(getpad(form_feed),
 658                     FFdelay, FFbits, &OFLAG(termmode));
 659                 setdelay(getpad(tab),
 660                     TBdelay, TBbits, &OFLAG(termmode));
 661 #endif  /* SYSV */
 662         }
 663
 664         /* If tabs can be sent to the tty, turn off their expansion. */
 665         if (tab && set_tab || init_tabs == 8) {
 666 #ifdef SYSV
 667                 OFLAG(termmodes) &= ~(TAB3);
 668 #else   /* SYSV */
 669                 OFLAG(termmode) &= ~(TAB3);
 670 #endif  /* SYSV */
 671         } else {
 672 #ifdef SYSV
 673                 OFLAG(termmodes) |= TAB3;
 674 #else   /* SYSV */
 675                 OFLAG(termmode) |= TAB3;
 676 #endif  /* SYSV */
 677         }
 678
 679         /* Do the changes to the terminal settings */
 680 #ifdef SYSV
 681         if (istermios < 0) {
 682                 int i;
 683
 684                 termmode.c_lflag = termmodes.c_lflag;
 685                 termmode.c_oflag = termmodes.c_oflag;
 686                 termmode.c_iflag = termmodes.c_iflag;
 687                 termmode.c_cflag = termmodes.c_cflag;
 688                 for (i = 0; i < NCC; i++)
 689                         termmode.c_cc[i] = termmodes.c_cc[i];
 690                 (void) STTY(filedes, &termmode);
 691         } else
 692                 (void) STTYS(filedes, &termmodes);
 693
 694 #else   /* SYSV */
 695         (void) STTY(filedes, &termmode);
 696 #endif  /* SYSV */
 697
 698         /* Send first initialization strings. */
 699         if (init_prog)
 700         (void) system(init_prog);
 701
 702         if (reset && reset_1string) {
 703                 putp(reset_1string);
 704         } else if (init_1string) {
 705                 putp(init_1string);
 706         }
 707
 708         if (reset && reset_2string) {
 709                 putp(reset_2string);
 710         } else if (init_2string) {
 711                 putp(init_2string);
 712         }
 713
 714         /* Set up the tabs stops. */
 715         settabs();
 716
 717         /* Send out initializing file. */
 718         if (reset && reset_file) {
 719                 cat(reset_file);
 720         } else if (init_file) {
 721                 cat(init_file);
 722         }
 723
 724         /* Send final initialization strings. */
 725         if (reset && reset_3string) {
 726                 putp(reset_3string);
 727         } else if (init_3string) {
 728                 putp(init_3string);
 729         }
 730
 731         if (carriage_return) {
 732                 putp(carriage_return);
 733         } else {
 734                 (void) putchar('\r');
 735         }
 736
 737         /* Send color initialization strings */
 738
 739         if (orig_colors)
 740                 putp(orig_colors);
 741
 742         if (orig_pair)
 743         putp(orig_pair);
 744
 745         /* Let the terminal settle down. */
 746         (void) fflush(stdout);
 747         (void) sleep(1);
 748 }
 749
 750 static void
 751 reset_term()
 752 {
 753         reset++;
 754         initterm();
 755 }