ncurses/tinfo/tinfo_driver.c

   1 /****************************************************************************
   2  * Copyright (c) 2008-2016,2017 Free Software Foundation, Inc.              *
   3  *                                                                          *
   4  * Permission is hereby granted, free of charge, to any person obtaining a  *
   5  * copy of this software and associated documentation files (the            *
   6  * "Software"), to deal in the Software without restriction, including      *
   7  * without limitation the rights to use, copy, modify, merge, publish,      *
   8  * distribute, distribute with modifications, sublicense, and/or sell       *
   9  * copies of the Software, and to permit persons to whom the Software is    *
  10  * furnished to do so, subject to the following conditions:                 *
  11  *                                                                          *
  12  * The above copyright notice and this permission notice shall be included  *
  13  * in all copies or substantial portions of the Software.                   *
  14  *                                                                          *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22  *                                                                          *
  23  * Except as contained in this notice, the name(s) of the above copyright   *
  24  * holders shall not be used in advertising or otherwise to promote the     *
  25  * sale, use or other dealings in this Software without prior written       *
  26  * authorization.                                                           *
  27  ****************************************************************************/
  28
  29 /****************************************************************************
  30  *  Author: Juergen Pfeifer                                                 *
  31  *     and: Thomas E. Dickey                                                *
  32  ****************************************************************************/
  33
  34 #include <curses.priv.h>
  35 #define CUR TerminalType((TERMINAL*)TCB).
  36 #include <tic.h>
  37 #include <termcap.h>            /* ospeed */
  38
  39 #if HAVE_NANOSLEEP
  40 #include <time.h>
  41 #if HAVE_SYS_TIME_H
  42 #include <sys/time.h>           /* needed for MacOS X DP3 */
  43 #endif
  44 #endif
  45
  46 #if HAVE_SIZECHANGE
  47 # if !defined(sun) || !TERMIOS
  48 #  if HAVE_SYS_IOCTL_H
  49 #   include <sys/ioctl.h>
  50 #  endif
  51 # endif
  52 #endif
  53
  54 MODULE_ID("$Id: tinfo_driver.c,v 1.59 2017/09/10 21:08:46 tom Exp $")
  55
  56 /*
  57  * SCO defines TIOCGSIZE and the corresponding struct.  Other systems (SunOS,
  58  * Solaris, IRIX) define TIOCGWINSZ and struct winsize.
  59  */
  60 #ifdef TIOCGSIZE
  61 # define IOCTL_WINSIZE TIOCGSIZE
  62 # define STRUCT_WINSIZE struct ttysize
  63 # define WINSIZE_ROWS(n) (int)n.ts_lines
  64 # define WINSIZE_COLS(n) (int)n.ts_cols
  65 #else
  66 # ifdef TIOCGWINSZ
  67 #  define IOCTL_WINSIZE TIOCGWINSZ
  68 #  define STRUCT_WINSIZE struct winsize
  69 #  define WINSIZE_ROWS(n) (int)n.ws_row
  70 #  define WINSIZE_COLS(n) (int)n.ws_col
  71 # endif
  72 #endif
  73
  74 /*
  75  * These should be screen structure members.  They need to be globals for
  76  * historical reasons.  So we assign them in start_color() and also in
  77  * set_term()'s screen-switching logic.
  78  */
  79 #if USE_REENTRANT
  80 NCURSES_EXPORT(int)
  81 NCURSES_PUBLIC_VAR(COLOR_PAIRS) (void)
  82 {
  83     return CURRENT_SCREEN ? CURRENT_SCREEN->_pair_count : -1;
  84 }
  85 NCURSES_EXPORT(int)
  86 NCURSES_PUBLIC_VAR(COLORS) (void)
  87 {
  88     return CURRENT_SCREEN ? CURRENT_SCREEN->_color_count : -1;
  89 }
  90 #else
  91 NCURSES_EXPORT_VAR(int) COLOR_PAIRS = 0;
  92 NCURSES_EXPORT_VAR(int) COLORS = 0;
  93 #endif
  94
  95 #define TCBMAGIC NCDRV_MAGIC(NCDRV_TINFO)
  96 #define AssertTCB() assert(TCB!=0 && TCB->magic==TCBMAGIC)
  97 #define SetSP() assert(TCB->csp!=0); sp = TCB->csp; (void) sp
  98
  99 /*
 100  * This routine needs to do all the work to make curscr look
 101  * like newscr.
 102  */
 103 static int
 104 drv_doupdate(TERMINAL_CONTROL_BLOCK * TCB)
 105 {
 106     AssertTCB();
 107     return TINFO_DOUPDATE(TCB->csp);
 108 }
 109
 110 static const char *
 111 drv_Name(TERMINAL_CONTROL_BLOCK * TCB)
 112 {
 113     (void) TCB;
 114     return "tinfo";
 115 }
 116
 117 static void
 118 get_baudrate(TERMINAL *termp)
 119 {
 120     int my_ospeed;
 121     int result;
 122     if (GET_TTY(termp->Filedes, &termp->Nttyb) == OK) {
 123 #ifdef TERMIOS
 124         termp->Nttyb.c_oflag &= (unsigned) (~OFLAGS_TABS);
 125 #else
 126         termp->Nttyb.sg_flags &= (unsigned) (~XTABS);
 127 #endif
 128     }
 129 #ifdef USE_OLD_TTY
 130     result = (int) cfgetospeed(&(termp->Nttyb));
 131     my_ospeed = (NCURSES_OSPEED) _nc_ospeed(result);
 132 #else /* !USE_OLD_TTY */
 133 #ifdef TERMIOS
 134     my_ospeed = (NCURSES_OSPEED) cfgetospeed(&(termp->Nttyb));
 135 #else
 136     my_ospeed = (NCURSES_OSPEED) termp->Nttyb.sg_ospeed;
 137 #endif
 138     result = _nc_baudrate(my_ospeed);
 139 #endif
 140     termp->_baudrate = result;
 141     ospeed = (NCURSES_OSPEED) my_ospeed;
 142 }
 143
 144 #undef SETUP_FAIL
 145 #define SETUP_FAIL FALSE
 146
 147 static bool
 148 drv_CanHandle(TERMINAL_CONTROL_BLOCK * TCB, const char *tname, int *errret)
 149 {
 150     bool result = FALSE;
 151     int status;
 152     TERMINAL *termp;
 153     SCREEN *sp;
 154
 155     START_TRACE();
 156     T((T_CALLED("tinfo::drv_CanHandle(%p)"), (void *) TCB));
 157
 158     assert(TCB != 0 && tname != 0);
 159     termp = (TERMINAL *) TCB;
 160     sp = TCB->csp;
 161     TCB->magic = TCBMAGIC;
 162
 163 #if (NCURSES_USE_DATABASE || NCURSES_USE_TERMCAP)
 164     status = _nc_setup_tinfo(tname, &TerminalType(termp));
 165 #else
 166     status = TGETENT_NO;
 167 #endif
 168
 169     /* try fallback list if entry on disk */
 170     if (status != TGETENT_YES) {
 171         const TERMTYPE2 *fallback = _nc_fallback2(tname);
 172
 173         if (fallback) {
 174             TerminalType(termp) = *fallback;
 175             status = TGETENT_YES;
 176         }
 177     }
 178
 179     if (status != TGETENT_YES) {
 180         NCURSES_SP_NAME(del_curterm) (NCURSES_SP_ARGx termp);
 181         if (status == TGETENT_ERR) {
 182             ret_error0(status, "terminals database is inaccessible\n");
 183         } else if (status == TGETENT_NO) {
 184             ret_error1(status, "unknown terminal type.\n", tname);
 185         }
 186     }
 187     result = TRUE;
 188 #if NCURSES_EXT_NUMBERS
 189     _nc_export_termtype2(&termp->type, &TerminalType(termp));
 190 #endif
 191 #if !USE_REENTRANT
 192     save_ttytype(termp);
 193 #endif
 194
 195     if (command_character)
 196         _nc_tinfo_cmdch(termp, *command_character);
 197
 198     /*
 199      * If an application calls setupterm() rather than initscr() or
 200      * newterm(), we will not have the def_prog_mode() call in
 201      * _nc_setupscreen().  Do it now anyway, so we can initialize the
 202      * baudrate.
 203      */
 204     if (sp == 0 && NC_ISATTY(termp->Filedes)) {
 205         get_baudrate(termp);
 206     }
 207 #if NCURSES_EXT_NUMBERS
 208 #define cleanup_termtype() \
 209     _nc_free_termtype2(&TerminalType(termp)); \
 210     _nc_free_termtype(&termp->type)
 211 #else
 212 #define cleanup_termtype() \
 213     _nc_free_termtype2(&TerminalType(termp))
 214 #endif
 215
 216     if (generic_type) {
 217         /*
 218          * BSD 4.3's termcap contains mis-typed "gn" for wy99.  Do a sanity
 219          * check before giving up.
 220          */
 221         if ((VALID_STRING(cursor_address)
 222              || (VALID_STRING(cursor_down) && VALID_STRING(cursor_home)))
 223             && VALID_STRING(clear_screen)) {
 224             cleanup_termtype();
 225             ret_error1(TGETENT_YES, "terminal is not really generic.\n", tname);
 226         } else {
 227             cleanup_termtype();
 228             ret_error1(TGETENT_NO, "I need something more specific.\n", tname);
 229         }
 230     }
 231     if (hard_copy) {
 232         cleanup_termtype();
 233         ret_error1(TGETENT_YES, "I can't handle hardcopy terminals.\n", tname);
 234     }
 235
 236     returnBool(result);
 237 }
 238
 239 static int
 240 drv_dobeepflash(TERMINAL_CONTROL_BLOCK * TCB, int beepFlag)
 241 {
 242     SCREEN *sp;
 243     int res = ERR;
 244
 245     AssertTCB();
 246     SetSP();
 247
 248     /* FIXME: should make sure that we are not in altchar mode */
 249     if (beepFlag) {
 250         if (bell) {
 251             res = NCURSES_PUTP2("bell", bell);
 252             NCURSES_SP_NAME(_nc_flush) (sp);
 253         } else if (flash_screen) {
 254             res = NCURSES_PUTP2("flash_screen", flash_screen);
 255             NCURSES_SP_NAME(_nc_flush) (sp);
 256         }
 257     } else {
 258         if (flash_screen) {
 259             res = NCURSES_PUTP2("flash_screen", flash_screen);
 260             NCURSES_SP_NAME(_nc_flush) (sp);
 261         } else if (bell) {
 262             res = NCURSES_PUTP2("bell", bell);
 263             NCURSES_SP_NAME(_nc_flush) (sp);
 264         }
 265     }
 266     return res;
 267 }
 268
 269 /*
 270  * SVr4 curses is known to interchange color codes (1,4) and (3,6), possibly
 271  * to maintain compatibility with a pre-ANSI scheme.  The same scheme is
 272  * also used in the FreeBSD syscons.
 273  */
 274 static int
 275 toggled_colors(int c)
 276 {
 277     if (c < 16) {
 278         static const int table[] =
 279         {0, 4, 2, 6, 1, 5, 3, 7,
 280          8, 12, 10, 14, 9, 13, 11, 15};
 281         c = table[c];
 282     }
 283     return c;
 284 }
 285
 286 static int
 287 drv_print(TERMINAL_CONTROL_BLOCK * TCB, char *data, int len)
 288 {
 289     SCREEN *sp;
 290
 291     AssertTCB();
 292     SetSP();
 293 #if NCURSES_EXT_FUNCS
 294     return NCURSES_SP_NAME(mcprint) (TCB->csp, data, len);
 295 #else
 296     return ERR;
 297 #endif
 298 }
 299
 300 static int
 301 drv_defaultcolors(TERMINAL_CONTROL_BLOCK * TCB, int fg, int bg)
 302 {
 303     SCREEN *sp;
 304     int code = ERR;
 305
 306     AssertTCB();
 307     SetSP();
 308
 309     if (sp != 0 && orig_pair && orig_colors && (initialize_pair != 0)) {
 310 #if NCURSES_EXT_FUNCS
 311         sp->_default_color = isDefaultColor(fg) || isDefaultColor(bg);
 312         sp->_has_sgr_39_49 = (NCURSES_SP_NAME(tigetflag) (NCURSES_SP_ARGx
 313                                                           "AX")
 314                               == TRUE);
 315         sp->_default_fg = isDefaultColor(fg) ? COLOR_DEFAULT : fg;
 316         sp->_default_bg = isDefaultColor(bg) ? COLOR_DEFAULT : bg;
 317         if (sp->_color_pairs != 0) {
 318             bool save = sp->_default_color;
 319             sp->_default_color = TRUE;
 320             NCURSES_SP_NAME(init_pair) (NCURSES_SP_ARGx
 321                                         0,
 322                                         (short)fg,
 323                                         (short)bg);
 324             sp->_default_color = save;
 325         }
 326 #endif
 327         code = OK;
 328     }
 329     return (code);
 330 }
 331
 332 static void
 333 drv_setcolor(TERMINAL_CONTROL_BLOCK * TCB,
 334              int fore,
 335              int color,
 336              NCURSES_SP_OUTC outc)
 337 {
 338     SCREEN *sp;
 339
 340     AssertTCB();
 341     SetSP();
 342
 343     if (fore) {
 344         if (set_a_foreground) {
 345             TPUTS_TRACE("set_a_foreground");
 346             NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
 347                                     TPARM_1(set_a_foreground, color), 1, outc);
 348         } else {
 349             TPUTS_TRACE("set_foreground");
 350             NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
 351                                     TPARM_1(set_foreground,
 352                                             toggled_colors(color)), 1, outc);
 353         }
 354     } else {
 355         if (set_a_background) {
 356             TPUTS_TRACE("set_a_background");
 357             NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
 358                                     TPARM_1(set_a_background, color), 1, outc);
 359         } else {
 360             TPUTS_TRACE("set_background");
 361             NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
 362                                     TPARM_1(set_background,
 363                                             toggled_colors(color)), 1, outc);
 364         }
 365     }
 366 }
 367
 368 static bool
 369 drv_rescol(TERMINAL_CONTROL_BLOCK * TCB)
 370 {
 371     bool result = FALSE;
 372     SCREEN *sp;
 373
 374     AssertTCB();
 375     SetSP();
 376
 377     if (orig_pair != 0) {
 378         NCURSES_PUTP2("orig_pair", orig_pair);
 379         result = TRUE;
 380     }
 381     return result;
 382 }
 383
 384 static bool
 385 drv_rescolors(TERMINAL_CONTROL_BLOCK * TCB)
 386 {
 387     int result = FALSE;
 388     SCREEN *sp;
 389
 390     AssertTCB();
 391     SetSP();
 392
 393     if (orig_colors != 0) {
 394         NCURSES_PUTP2("orig_colors", orig_colors);
 395         result = TRUE;
 396     }
 397     return result;
 398 }
 399
 400 static int
 401 drv_size(TERMINAL_CONTROL_BLOCK * TCB, int *linep, int *colp)
 402 {
 403     SCREEN *sp;
 404     bool useEnv = TRUE;
 405     bool useTioctl = TRUE;
 406
 407     AssertTCB();
 408     sp = TCB->csp;              /* can be null here */
 409
 410     if (sp) {
 411         useEnv = sp->_use_env;
 412         useTioctl = sp->use_tioctl;
 413     } else {
 414         useEnv = _nc_prescreen.use_env;
 415         useTioctl = _nc_prescreen.use_tioctl;
 416     }
 417
 418     /* figure out the size of the screen */
 419     T(("screen size: terminfo lines = %d columns = %d", lines, columns));
 420
 421     *linep = (int) lines;
 422     *colp = (int) columns;
 423
 424     if (useEnv || useTioctl) {
 425         int value;
 426
 427 #ifdef __EMX__
 428         {
 429             int screendata[2];
 430             _scrsize(screendata);
 431             *colp = screendata[0];
 432             *linep = ((sp != 0 && sp->_filtered)
 433                       ? 1
 434                       : screendata[1]);
 435             T(("EMX screen size: environment LINES = %d COLUMNS = %d",
 436                *linep, *colp));
 437         }
 438 #endif
 439 #if HAVE_SIZECHANGE
 440         /* try asking the OS */
 441         {
 442             TERMINAL *termp = (TERMINAL *) TCB;
 443             if (NC_ISATTY(termp->Filedes)) {
 444                 STRUCT_WINSIZE size;
 445
 446                 errno = 0;
 447                 do {
 448                     if (ioctl(termp->Filedes, IOCTL_WINSIZE, &size) >= 0) {
 449                         *linep = ((sp != 0 && sp->_filtered)
 450                                   ? 1
 451                                   : WINSIZE_ROWS(size));
 452                         *colp = WINSIZE_COLS(size);
 453                         T(("SYS screen size: environment LINES = %d COLUMNS = %d",
 454                            *linep, *colp));
 455                         break;
 456                     }
 457                 } while
 458                     (errno == EINTR);
 459             }
 460         }
 461 #endif /* HAVE_SIZECHANGE */
 462
 463         if (useEnv) {
 464             if (useTioctl) {
 465                 /*
 466                  * If environment variables are used, update them.
 467                  */
 468                 if ((sp == 0 || !sp->_filtered) && _nc_getenv_num("LINES") > 0) {
 469                     _nc_setenv_num("LINES", *linep);
 470                 }
 471                 if (_nc_getenv_num("COLUMNS") > 0) {
 472                     _nc_setenv_num("COLUMNS", *colp);
 473                 }
 474             }
 475
 476             /*
 477              * Finally, look for environment variables.
 478              *
 479              * Solaris lets users override either dimension with an environment
 480              * variable.
 481              */
 482             if ((value = _nc_getenv_num("LINES")) > 0) {
 483                 *linep = value;
 484                 T(("screen size: environment LINES = %d", *linep));
 485             }
 486             if ((value = _nc_getenv_num("COLUMNS")) > 0) {
 487                 *colp = value;
 488                 T(("screen size: environment COLUMNS = %d", *colp));
 489             }
 490         }
 491
 492         /* if we can't get dynamic info about the size, use static */
 493         if (*linep <= 0) {
 494             *linep = (int) lines;
 495         }
 496         if (*colp <= 0) {
 497             *colp = (int) columns;
 498         }
 499
 500         /* the ultimate fallback, assume fixed 24x80 size */
 501         if (*linep <= 0) {
 502             *linep = 24;
 503         }
 504         if (*colp <= 0) {
 505             *colp = 80;
 506         }
 507
 508         /*
 509          * Put the derived values back in the screen-size caps, so
 510          * tigetnum() and tgetnum() will do the right thing.
 511          */
 512         lines = (short) (*linep);
 513         columns = (short) (*colp);
 514     }
 515
 516     T(("screen size is %dx%d", *linep, *colp));
 517     return OK;
 518 }
 519
 520 static int
 521 drv_getsize(TERMINAL_CONTROL_BLOCK * TCB, int *l, int *c)
 522 {
 523     AssertTCB();
 524     assert(l != 0 && c != 0);
 525     *l = lines;
 526     *c = columns;
 527     return OK;
 528 }
 529
 530 static int
 531 drv_setsize(TERMINAL_CONTROL_BLOCK * TCB, int l, int c)
 532 {
 533     AssertTCB();
 534     lines = (short) l;
 535     columns = (short) c;
 536     return OK;
 537 }
 538
 539 static int
 540 drv_sgmode(TERMINAL_CONTROL_BLOCK * TCB, int setFlag, TTY * buf)
 541 {
 542     SCREEN *sp = TCB->csp;
 543     TERMINAL *_term = (TERMINAL *) TCB;
 544     int result = OK;
 545
 546     AssertTCB();
 547     if (setFlag) {
 548         for (;;) {
 549             if (SET_TTY(_term->Filedes, buf) != 0) {
 550                 if (errno == EINTR)
 551                     continue;
 552                 if (errno == ENOTTY) {
 553                     if (sp)
 554                         sp->_notty = TRUE;
 555                 }
 556                 result = ERR;
 557             }
 558             break;
 559         }
 560     } else {
 561         for (;;) {
 562             if (GET_TTY(_term->Filedes, buf) != 0) {
 563                 if (errno == EINTR)
 564                     continue;
 565                 result = ERR;
 566             }
 567             break;
 568         }
 569     }
 570     return result;
 571 }
 572
 573 static int
 574 drv_mode(TERMINAL_CONTROL_BLOCK * TCB, int progFlag, int defFlag)
 575 {
 576     SCREEN *sp;
 577     TERMINAL *_term = (TERMINAL *) TCB;
 578     int code = ERR;
 579
 580     AssertTCB();
 581     sp = TCB->csp;
 582
 583     if (progFlag)               /* prog mode */
 584     {
 585         if (defFlag) {
 586             /* def_prog_mode */
 587             /*
 588              * Turn off the XTABS bit in the tty structure if it was on.
 589              */
 590             if ((drv_sgmode(TCB, FALSE, &(_term->Nttyb)) == OK)) {
 591 #ifdef TERMIOS
 592                 _term->Nttyb.c_oflag &= (unsigned) ~OFLAGS_TABS;
 593 #else
 594                 _term->Nttyb.sg_flags &= (unsigned) ~XTABS;
 595 #endif
 596                 code = OK;
 597             }
 598         } else {
 599             /* reset_prog_mode */
 600             if (drv_sgmode(TCB, TRUE, &(_term->Nttyb)) == OK) {
 601                 if (sp) {
 602                     if (sp->_keypad_on)
 603                         _nc_keypad(sp, TRUE);
 604                 }
 605                 code = OK;
 606             }
 607         }
 608     } else {                    /* shell mode */
 609         if (defFlag) {
 610             /* def_shell_mode */
 611             /*
 612              * If XTABS was on, remove the tab and backtab capabilities.
 613              */
 614             if (drv_sgmode(TCB, FALSE, &(_term->Ottyb)) == OK) {
 615 #ifdef TERMIOS
 616                 if (_term->Ottyb.c_oflag & OFLAGS_TABS)
 617                     tab = back_tab = NULL;
 618 #else
 619                 if (_term->Ottyb.sg_flags & XTABS)
 620                     tab = back_tab = NULL;
 621 #endif
 622                 code = OK;
 623             }
 624         } else {
 625             /* reset_shell_mode */
 626             if (sp) {
 627                 _nc_keypad(sp, FALSE);
 628                 NCURSES_SP_NAME(_nc_flush) (sp);
 629             }
 630             code = drv_sgmode(TCB, TRUE, &(_term->Ottyb));
 631         }
 632     }
 633     return (code);
 634 }
 635
 636 static void
 637 drv_wrap(SCREEN *sp)
 638 {
 639     if (sp) {
 640         sp->_mouse_wrap(sp);
 641         NCURSES_SP_NAME(_nc_screen_wrap) (sp);
 642         NCURSES_SP_NAME(_nc_mvcur_wrap) (sp);   /* wrap up cursor addressing */
 643     }
 644 }
 645
 646 static void
 647 drv_release(TERMINAL_CONTROL_BLOCK * TCB GCC_UNUSED)
 648 {
 649 }
 650
 651 #  define SGR0_TEST(mode) (mode != 0) && (exit_attribute_mode == 0 || strcmp(mode, exit_attribute_mode))
 652
 653 static void
 654 drv_screen_init(SCREEN *sp)
 655 {
 656     TERMINAL_CONTROL_BLOCK *TCB = TCBOf(sp);
 657
 658     AssertTCB();
 659
 660     /*
 661      * Check for mismatched graphic-rendition capabilities.  Most SVr4
 662      * terminfo trees contain entries that have rmul or rmso equated to
 663      * sgr0 (Solaris curses copes with those entries).  We do this only
 664      * for curses, since many termcap applications assume that
 665      * smso/rmso and smul/rmul are paired, and will not function
 666      * properly if we remove rmso or rmul.  Curses applications
 667      * shouldn't be looking at this detail.
 668      */
 669     sp->_use_rmso = SGR0_TEST(exit_standout_mode);
 670     sp->_use_rmul = SGR0_TEST(exit_underline_mode);
 671
 672     /*
 673      * Check whether we can optimize scrolling under dumb terminals in
 674      * case we do not have any of these capabilities, scrolling
 675      * optimization will be useless.
 676      */
 677     sp->_scrolling = ((scroll_forward && scroll_reverse) ||
 678                       ((parm_rindex ||
 679                         parm_insert_line ||
 680                         insert_line) &&
 681                        (parm_index ||
 682                         parm_delete_line ||
 683                         delete_line)));
 684
 685     NCURSES_SP_NAME(baudrate) (sp);
 686
 687     NCURSES_SP_NAME(_nc_mvcur_init) (sp);
 688     /* initialize terminal to a sane state */
 689     NCURSES_SP_NAME(_nc_screen_init) (sp);
 690 }
 691
 692 static void
 693 drv_init(TERMINAL_CONTROL_BLOCK * TCB)
 694 {
 695     TERMINAL *trm;
 696
 697     AssertTCB();
 698
 699     trm = (TERMINAL *) TCB;
 700
 701     TCB->info.initcolor = VALID_STRING(initialize_color);
 702     TCB->info.canchange = can_change;
 703     TCB->info.hascolor = ((VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs)
 704                            && (((set_foreground != NULL)
 705                                 && (set_background != NULL))
 706                                || ((set_a_foreground != NULL)
 707                                    && (set_a_background != NULL))
 708                                || set_color_pair)) ? TRUE : FALSE);
 709
 710     TCB->info.caninit = !(exit_ca_mode && non_rev_rmcup);
 711
 712     TCB->info.maxpairs = VALID_NUMERIC(max_pairs) ? max_pairs : 0;
 713     TCB->info.maxcolors = VALID_NUMERIC(max_colors) ? max_colors : 0;
 714     TCB->info.numlabels = VALID_NUMERIC(num_labels) ? num_labels : 0;
 715     TCB->info.labelwidth = VALID_NUMERIC(label_width) ? label_width : 0;
 716     TCB->info.labelheight = VALID_NUMERIC(label_height) ? label_height : 0;
 717     TCB->info.nocolorvideo = VALID_NUMERIC(no_color_video) ? no_color_video
 718         : 0;
 719     TCB->info.tabsize = VALID_NUMERIC(init_tabs) ? (int) init_tabs : 8;
 720
 721     TCB->info.defaultPalette = hue_lightness_saturation ? _nc_hls_palette : _nc_cga_palette;
 722
 723     /*
 724      * If an application calls setupterm() rather than initscr() or
 725      * newterm(), we will not have the def_prog_mode() call in
 726      * _nc_setupscreen().  Do it now anyway, so we can initialize the
 727      * baudrate.
 728      */
 729     if (NC_ISATTY(trm->Filedes)) {
 730         TCB->drv->td_mode(TCB, TRUE, TRUE);
 731     }
 732 }
 733
 734 #define MAX_PALETTE     8
 735 #define InPalette(n)    ((n) >= 0 && (n) < MAX_PALETTE)
 736
 737 static void
 738 drv_initpair(TERMINAL_CONTROL_BLOCK * TCB, int pair, int f, int b)
 739 {
 740     SCREEN *sp;
 741
 742     AssertTCB();
 743     SetSP();
 744
 745     if ((initialize_pair != NULL) && InPalette(f) && InPalette(b)) {
 746         const color_t *tp = InfoOf(sp).defaultPalette;
 747
 748         TR(TRACE_ATTRS,
 749            ("initializing pair: pair = %d, fg=(%d,%d,%d), bg=(%d,%d,%d)",
 750             pair,
 751             tp[f].red, tp[f].green, tp[f].blue,
 752             tp[b].red, tp[b].green, tp[b].blue));
 753
 754         NCURSES_PUTP2("initialize_pair",
 755                       TPARM_7(initialize_pair,
 756                               pair,
 757                               tp[f].red, tp[f].green, tp[f].blue,
 758                               tp[b].red, tp[b].green, tp[b].blue));
 759     }
 760 }
 761
 762 static int
 763 default_fg(SCREEN *sp)
 764 {
 765 #if NCURSES_EXT_FUNCS
 766     return (sp != 0) ? sp->_default_fg : COLOR_WHITE;
 767 #else
 768     return COLOR_WHITE;
 769 #endif
 770 }
 771
 772 static int
 773 default_bg(SCREEN *sp)
 774 {
 775 #if NCURSES_EXT_FUNCS
 776     return sp != 0 ? sp->_default_bg : COLOR_BLACK;
 777 #else
 778     return COLOR_BLACK;
 779 #endif
 780 }
 781
 782 static void
 783 drv_initcolor(TERMINAL_CONTROL_BLOCK * TCB,
 784               int color, int r, int g, int b)
 785 {
 786     SCREEN *sp = TCB->csp;
 787
 788     AssertTCB();
 789     if (initialize_color != NULL) {
 790         NCURSES_PUTP2("initialize_color",
 791                       TPARM_4(initialize_color, color, r, g, b));
 792     }
 793 }
 794
 795 static void
 796 drv_do_color(TERMINAL_CONTROL_BLOCK * TCB,
 797              int old_pair,
 798              int pair,
 799              int reverse,
 800              NCURSES_SP_OUTC outc)
 801 {
 802     SCREEN *sp = TCB->csp;
 803     int fg = COLOR_DEFAULT;
 804     int bg = COLOR_DEFAULT;
 805     int old_fg, old_bg;
 806
 807     AssertTCB();
 808     if (sp == 0)
 809         return;
 810
 811     if (pair < 0 || pair >= COLOR_PAIRS) {
 812         return;
 813     } else if (pair != 0) {
 814         if (set_color_pair) {
 815             TPUTS_TRACE("set_color_pair");
 816             NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
 817                                     TPARM_1(set_color_pair, pair), 1, outc);
 818             return;
 819         } else if (sp != 0) {
 820             _nc_pair_content(SP_PARM, pair, &fg, &bg);
 821         }
 822     }
 823
 824     if (old_pair >= 0
 825         && sp != 0
 826         && _nc_pair_content(SP_PARM, old_pair, &old_fg, &old_bg) != ERR) {
 827         if ((isDefaultColor(fg) && !isDefaultColor(old_fg))
 828             || (isDefaultColor(bg) && !isDefaultColor(old_bg))) {
 829 #if NCURSES_EXT_FUNCS
 830             /*
 831              * A minor optimization - but extension.  If "AX" is specified in
 832              * the terminal description, treat it as screen's indicator of ECMA
 833              * SGR 39 and SGR 49, and assume the two sequences are independent.
 834              */
 835             if (sp->_has_sgr_39_49
 836                 && isDefaultColor(old_bg)
 837                 && !isDefaultColor(old_fg)) {
 838                 NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx "\033[39m", 1, outc);
 839             } else if (sp->_has_sgr_39_49
 840                        && isDefaultColor(old_fg)
 841                        && !isDefaultColor(old_bg)) {
 842                 NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx "\033[49m", 1, outc);
 843             } else
 844 #endif
 845                 drv_rescol(TCB);
 846         }
 847     } else {
 848         drv_rescol(TCB);
 849         if (old_pair < 0)
 850             return;
 851     }
 852
 853 #if NCURSES_EXT_FUNCS
 854     if (isDefaultColor(fg))
 855         fg = default_fg(sp);
 856     if (isDefaultColor(bg))
 857         bg = default_bg(sp);
 858 #endif
 859
 860     if (reverse) {
 861         int xx = fg;
 862         fg = bg;
 863         bg = xx;
 864     }
 865
 866     TR(TRACE_ATTRS, ("setting colors: pair = %d, fg = %d, bg = %d", pair,
 867                      fg, bg));
 868
 869     if (!isDefaultColor(fg)) {
 870         drv_setcolor(TCB, TRUE, fg, outc);
 871     }
 872     if (!isDefaultColor(bg)) {
 873         drv_setcolor(TCB, FALSE, bg, outc);
 874     }
 875 }
 876
 877 #define xterm_kmous "\033[M"
 878 static void
 879 init_xterm_mouse(SCREEN *sp)
 880 {
 881     sp->_mouse_type = M_XTERM;
 882     sp->_mouse_xtermcap = NCURSES_SP_NAME(tigetstr) (NCURSES_SP_ARGx "XM");
 883     if (!VALID_STRING(sp->_mouse_xtermcap))
 884         sp->_mouse_xtermcap = "\033[?1000%?%p1%{1}%=%th%el%;";
 885 }
 886
 887 static void
 888 drv_initmouse(TERMINAL_CONTROL_BLOCK * TCB)
 889 {
 890     SCREEN *sp;
 891
 892     AssertTCB();
 893     SetSP();
 894
 895     /* we know how to recognize mouse events under "xterm" */
 896     if (sp != 0) {
 897         if (key_mouse != 0) {
 898             if (!strcmp(key_mouse, xterm_kmous)
 899                 || strstr(SP_TERMTYPE term_names, "xterm") != 0) {
 900                 init_xterm_mouse(sp);
 901             }
 902         } else if (strstr(SP_TERMTYPE term_names, "xterm") != 0) {
 903             if (_nc_add_to_try(&(sp->_keytry), xterm_kmous, KEY_MOUSE) == OK)
 904                 init_xterm_mouse(sp);
 905         }
 906     }
 907 }
 908
 909 static int
 910 drv_testmouse(TERMINAL_CONTROL_BLOCK * TCB,
 911               int delay
 912               EVENTLIST_2nd(_nc_eventlist * evl))
 913 {
 914     int rc = 0;
 915     SCREEN *sp;
 916
 917     AssertTCB();
 918     SetSP();
 919
 920 #if USE_SYSMOUSE
 921     if ((sp->_mouse_type == M_SYSMOUSE)
 922         && (sp->_sysmouse_head < sp->_sysmouse_tail)) {
 923         rc = TW_MOUSE;
 924     } else
 925 #endif
 926     {
 927         rc = TCBOf(sp)->drv->td_twait(TCBOf(sp),
 928                                       TWAIT_MASK,
 929                                       delay,
 930                                       (int *) 0
 931                                       EVENTLIST_2nd(evl));
 932 #if USE_SYSMOUSE
 933         if ((sp->_mouse_type == M_SYSMOUSE)
 934             && (sp->_sysmouse_head < sp->_sysmouse_tail)
 935             && (rc == 0)
 936             && (errno == EINTR)) {
 937             rc |= TW_MOUSE;
 938         }
 939 #endif
 940     }
 941     return rc;
 942 }
 943
 944 static int
 945 drv_mvcur(TERMINAL_CONTROL_BLOCK * TCB, int yold, int xold, int ynew, int xnew)
 946 {
 947     SCREEN *sp = TCB->csp;
 948     AssertTCB();
 949     return NCURSES_SP_NAME(_nc_mvcur) (sp, yold, xold, ynew, xnew);
 950 }
 951
 952 static void
 953 drv_hwlabel(TERMINAL_CONTROL_BLOCK * TCB, int labnum, char *text)
 954 {
 955     SCREEN *sp = TCB->csp;
 956
 957     AssertTCB();
 958     if (labnum > 0 && labnum <= num_labels) {
 959         NCURSES_PUTP2("plab_norm",
 960                       TPARM_2(plab_norm, labnum, text));
 961     }
 962 }
 963
 964 static void
 965 drv_hwlabelOnOff(TERMINAL_CONTROL_BLOCK * TCB, int OnFlag)
 966 {
 967     SCREEN *sp = TCB->csp;
 968
 969     AssertTCB();
 970     if (OnFlag) {
 971         NCURSES_PUTP2("label_on", label_on);
 972     } else {
 973         NCURSES_PUTP2("label_off", label_off);
 974     }
 975 }
 976
 977 static chtype
 978 drv_conattr(TERMINAL_CONTROL_BLOCK * TCB)
 979 {
 980     SCREEN *sp = TCB->csp;
 981     chtype attrs = A_NORMAL;
 982
 983     AssertTCB();
 984     if (enter_alt_charset_mode)
 985         attrs |= A_ALTCHARSET;
 986
 987     if (enter_blink_mode)
 988         attrs |= A_BLINK;
 989
 990     if (enter_bold_mode)
 991         attrs |= A_BOLD;
 992
 993     if (enter_dim_mode)
 994         attrs |= A_DIM;
 995
 996     if (enter_reverse_mode)
 997         attrs |= A_REVERSE;
 998
 999     if (enter_standout_mode)
1000         attrs |= A_STANDOUT;
1001
1002     if (enter_protected_mode)
1003         attrs |= A_PROTECT;
1004
1005     if (enter_secure_mode)
1006         attrs |= A_INVIS;
1007
1008     if (enter_underline_mode)
1009         attrs |= A_UNDERLINE;
1010
1011     if (sp && sp->_coloron)
1012         attrs |= A_COLOR;
1013
1014 #if USE_ITALIC
1015     if (enter_italics_mode)
1016         attrs |= A_ITALIC;
1017 #endif
1018
1019     return (attrs);
1020 }
1021
1022 static void
1023 drv_setfilter(TERMINAL_CONTROL_BLOCK * TCB)
1024 {
1025     AssertTCB();
1026
1027     /* *INDENT-EQLS* */
1028     clear_screen     = ABSENT_STRING;
1029     cursor_address   = ABSENT_STRING;
1030     cursor_down      = ABSENT_STRING;
1031     cursor_up        = ABSENT_STRING;
1032     parm_down_cursor = ABSENT_STRING;
1033     parm_up_cursor   = ABSENT_STRING;
1034     row_address      = ABSENT_STRING;
1035     cursor_home      = carriage_return;
1036
1037     if (back_color_erase)
1038         clr_eos = ABSENT_STRING;
1039 }
1040
1041 static void
1042 drv_initacs(TERMINAL_CONTROL_BLOCK * TCB, chtype *real_map, chtype *fake_map)
1043 {
1044     SCREEN *sp = TCB->csp;
1045
1046     AssertTCB();
1047     assert(sp != 0);
1048     if (ena_acs != NULL) {
1049         NCURSES_PUTP2("ena_acs", ena_acs);
1050     }
1051 #if NCURSES_EXT_FUNCS
1052     /*
1053      * Linux console "supports" the "PC ROM" character set by the coincidence
1054      * that smpch/rmpch and smacs/rmacs have the same values.  ncurses has
1055      * no codepage support (see SCO Merge for an example).  Outside of the
1056      * values defined in acsc, there are no definitions for the "PC ROM"
1057      * character set (assumed by some applications to be codepage 437), but we
1058      * allow those applications to use those codepoints.
1059      *
1060      * test/blue.c uses this feature.
1061      */
1062 #define PCH_KLUDGE(a,b) (a != 0 && b != 0 && !strcmp(a,b))
1063     if (PCH_KLUDGE(enter_pc_charset_mode, enter_alt_charset_mode) &&
1064         PCH_KLUDGE(exit_pc_charset_mode, exit_alt_charset_mode)) {
1065         size_t i;
1066         for (i = 1; i < ACS_LEN; ++i) {
1067             if (real_map[i] == 0) {
1068                 real_map[i] = (chtype) i;
1069                 if (real_map != fake_map) {
1070                     if (sp != 0)
1071                         sp->_screen_acs_map[i] = TRUE;
1072                 }
1073             }
1074         }
1075     }
1076 #endif
1077
1078     if (acs_chars != NULL) {
1079         size_t i = 0;
1080         size_t length = strlen(acs_chars);
1081
1082         while (i + 1 < length) {
1083             if (acs_chars[i] != 0 && UChar(acs_chars[i]) < ACS_LEN) {
1084                 real_map[UChar(acs_chars[i])] = UChar(acs_chars[i + 1]) | A_ALTCHARSET;
1085                 if (sp != 0)
1086                     sp->_screen_acs_map[UChar(acs_chars[i])] = TRUE;
1087             }
1088             i += 2;
1089         }
1090     }
1091 #ifdef TRACE
1092     /* Show the equivalent mapping, noting if it does not match the
1093      * given attribute, whether by re-ordering or duplication.
1094      */
1095     if (USE_TRACEF(TRACE_CALLS)) {
1096         size_t n, m;
1097         char show[ACS_LEN * 2 + 1];
1098         for (n = 1, m = 0; n < ACS_LEN; n++) {
1099             if (real_map[n] != 0) {
1100                 show[m++] = (char) n;
1101                 show[m++] = (char) ChCharOf(real_map[n]);
1102             }
1103         }
1104         show[m] = 0;
1105         if (acs_chars == NULL || strcmp(acs_chars, show))
1106             _tracef("%s acs_chars %s",
1107                     (acs_chars == NULL) ? "NULL" : "READ",
1108                     _nc_visbuf(acs_chars));
1109         _tracef("%s acs_chars %s",
1110                 (acs_chars == NULL)
1111                 ? "NULL"
1112                 : (strcmp(acs_chars, show)
1113                    ? "DIFF"
1114                    : "SAME"),
1115                 _nc_visbuf(show));
1116
1117         _nc_unlock_global(tracef);
1118     }
1119 #endif /* TRACE */
1120 }
1121
1122 #define ENSURE_TINFO(sp) (TCBOf(sp)->drv->isTerminfo)
1123
1124 NCURSES_EXPORT(void)
1125 _nc_cookie_init(SCREEN *sp)
1126 {
1127     bool support_cookies = USE_XMC_SUPPORT;
1128     TERMINAL_CONTROL_BLOCK *TCB = (TERMINAL_CONTROL_BLOCK *) (sp->_term);
1129
1130     if (sp == 0 || !ENSURE_TINFO(sp))
1131         return;
1132
1133 #if USE_XMC_SUPPORT
1134     /*
1135      * If we have no magic-cookie support compiled-in, or if it is suppressed
1136      * in the environment, reset the support-flag.
1137      */
1138     if (magic_cookie_glitch >= 0) {
1139         if (getenv("NCURSES_NO_MAGIC_COOKIE") != 0) {
1140             support_cookies = FALSE;
1141         }
1142     }
1143 #endif
1144
1145     if (!support_cookies && magic_cookie_glitch >= 0) {
1146         T(("will disable attributes to work w/o magic cookies"));
1147     }
1148
1149     if (magic_cookie_glitch > 0) {      /* tvi, wyse */
1150
1151         sp->_xmc_triggers = sp->_ok_attributes & XMC_CONFLICT;
1152 #if 0
1153         /*
1154          * We "should" treat colors as an attribute.  The wyse350 (and its
1155          * clones) appear to be the only ones that have both colors and magic
1156          * cookies.
1157          */
1158         if (has_colors()) {
1159             sp->_xmc_triggers |= A_COLOR;
1160         }
1161 #endif
1162         sp->_xmc_suppress = sp->_xmc_triggers & (chtype) ~(A_BOLD);
1163
1164         T(("magic cookie attributes %s", _traceattr(sp->_xmc_suppress)));
1165         /*
1166          * Supporting line-drawing may be possible.  But make the regular
1167          * video attributes work first.
1168          */
1169         acs_chars = ABSENT_STRING;
1170         ena_acs = ABSENT_STRING;
1171         enter_alt_charset_mode = ABSENT_STRING;
1172         exit_alt_charset_mode = ABSENT_STRING;
1173 #if USE_XMC_SUPPORT
1174         /*
1175          * To keep the cookie support simple, suppress all of the optimization
1176          * hooks except for clear_screen and the cursor addressing.
1177          */
1178         if (support_cookies) {
1179             clr_eol = ABSENT_STRING;
1180             clr_eos = ABSENT_STRING;
1181             set_attributes = ABSENT_STRING;
1182         }
1183 #endif
1184     } else if (magic_cookie_glitch == 0) {      /* hpterm */
1185     }
1186
1187     /*
1188      * If magic cookies are not supported, cancel the strings that set
1189      * video attributes.
1190      */
1191     if (!support_cookies && magic_cookie_glitch >= 0) {
1192         magic_cookie_glitch = ABSENT_NUMERIC;
1193         set_attributes = ABSENT_STRING;
1194         enter_blink_mode = ABSENT_STRING;
1195         enter_bold_mode = ABSENT_STRING;
1196         enter_dim_mode = ABSENT_STRING;
1197         enter_reverse_mode = ABSENT_STRING;
1198         enter_standout_mode = ABSENT_STRING;
1199         enter_underline_mode = ABSENT_STRING;
1200     }
1201
1202     /* initialize normal acs before wide, since we use mapping in the latter */
1203 #if !USE_WIDEC_SUPPORT
1204     if (_nc_unicode_locale() && _nc_locale_breaks_acs(sp->_term)) {
1205         acs_chars = NULL;
1206         ena_acs = NULL;
1207         enter_alt_charset_mode = NULL;
1208         exit_alt_charset_mode = NULL;
1209         set_attributes = NULL;
1210     }
1211 #endif
1212 }
1213
1214 static int
1215 drv_twait(TERMINAL_CONTROL_BLOCK * TCB,
1216           int mode,
1217           int milliseconds,
1218           int *timeleft
1219           EVENTLIST_2nd(_nc_eventlist * evl))
1220 {
1221     SCREEN *sp;
1222
1223     AssertTCB();
1224     SetSP();
1225
1226     return _nc_timed_wait(sp, mode, milliseconds, timeleft EVENTLIST_2nd(evl));
1227 }
1228
1229 static int
1230 drv_read(TERMINAL_CONTROL_BLOCK * TCB, int *buf)
1231 {
1232     SCREEN *sp;
1233     unsigned char c2 = 0;
1234     int n;
1235
1236     AssertTCB();
1237     assert(buf);
1238     SetSP();
1239
1240 # if USE_PTHREADS_EINTR
1241     if ((pthread_self) && (pthread_kill) && (pthread_equal))
1242         _nc_globals.read_thread = pthread_self();
1243 # endif
1244     n = (int) read(sp->_ifd, &c2, (size_t) 1);
1245 #if USE_PTHREADS_EINTR
1246     _nc_globals.read_thread = 0;
1247 #endif
1248     *buf = (int) c2;
1249     return n;
1250 }
1251
1252 static int
1253 drv_nap(TERMINAL_CONTROL_BLOCK * TCB GCC_UNUSED, int ms)
1254 {
1255 #if HAVE_NANOSLEEP
1256     {
1257         struct timespec request, remaining;
1258         request.tv_sec = ms / 1000;
1259         request.tv_nsec = (ms % 1000) * 1000000;
1260         while (nanosleep(&request, &remaining) == -1
1261                && errno == EINTR) {
1262             request = remaining;
1263         }
1264     }
1265 #else
1266     _nc_timed_wait(0, 0, ms, (int *) 0 EVENTLIST_2nd(0));
1267 #endif
1268     return OK;
1269 }
1270
1271 static int
1272 __nc_putp(SCREEN *sp, const char *name GCC_UNUSED, const char *value)
1273 {
1274     int rc = ERR;
1275
1276     if (value) {
1277         rc = NCURSES_PUTP2(name, value);
1278     }
1279     return rc;
1280 }
1281
1282 static int
1283 __nc_putp_flush(SCREEN *sp, const char *name, const char *value)
1284 {
1285     int rc = __nc_putp(sp, name, value);
1286     if (rc != ERR) {
1287         NCURSES_SP_NAME(_nc_flush) (sp);
1288     }
1289     return rc;
1290 }
1291
1292 static int
1293 drv_kpad(TERMINAL_CONTROL_BLOCK * TCB, int flag)
1294 {
1295     int ret = ERR;
1296     SCREEN *sp;
1297
1298     AssertTCB();
1299
1300     sp = TCB->csp;
1301
1302     if (sp) {
1303         if (flag) {
1304             (void) __nc_putp_flush(sp, "keypad_xmit", keypad_xmit);
1305         } else if (!flag && keypad_local) {
1306             (void) __nc_putp_flush(sp, "keypad_local", keypad_local);
1307         }
1308         if (flag && !sp->_tried) {
1309             _nc_init_keytry(sp);
1310             sp->_tried = TRUE;
1311         }
1312         ret = OK;
1313     }
1314
1315     return ret;
1316 }
1317
1318 static int
1319 drv_keyok(TERMINAL_CONTROL_BLOCK * TCB, int c, int flag)
1320 {
1321     SCREEN *sp;
1322     int code = ERR;
1323     int count = 0;
1324     char *s;
1325
1326     AssertTCB();
1327     SetSP();
1328
1329     if (c >= 0) {
1330         unsigned ch = (unsigned) c;
1331         if (flag) {
1332             while ((s = _nc_expand_try(sp->_key_ok,
1333                                        ch, &count, (size_t) 0)) != 0
1334                    && _nc_remove_key(&(sp->_key_ok), ch)) {
1335                 code = _nc_add_to_try(&(sp->_keytry), s, ch);
1336                 free(s);
1337                 count = 0;
1338                 if (code != OK)
1339                     break;
1340             }
1341         } else {
1342             while ((s = _nc_expand_try(sp->_keytry,
1343                                        ch, &count, (size_t) 0)) != 0
1344                    && _nc_remove_key(&(sp->_keytry), ch)) {
1345                 code = _nc_add_to_try(&(sp->_key_ok), s, ch);
1346                 free(s);
1347                 count = 0;
1348                 if (code != OK)
1349                     break;
1350             }
1351         }
1352     }
1353     return (code);
1354 }
1355
1356 static int
1357 drv_cursorSet(TERMINAL_CONTROL_BLOCK * TCB, int vis)
1358 {
1359     SCREEN *sp;
1360     int code = ERR;
1361
1362     AssertTCB();
1363     SetSP();
1364
1365     T((T_CALLED("tinfo:drv_cursorSet(%p,%d)"), (void *) SP_PARM, vis));
1366
1367     if (SP_PARM != 0 && IsTermInfo(SP_PARM)) {
1368         switch (vis) {
1369         case 2:
1370             code = NCURSES_PUTP2_FLUSH("cursor_visible", cursor_visible);
1371             break;
1372         case 1:
1373             code = NCURSES_PUTP2_FLUSH("cursor_normal", cursor_normal);
1374             break;
1375         case 0:
1376             code = NCURSES_PUTP2_FLUSH("cursor_invisible", cursor_invisible);
1377             break;
1378         }
1379     } else {
1380         code = ERR;
1381     }
1382     returnCode(code);
1383 }
1384
1385 static bool
1386 drv_kyExist(TERMINAL_CONTROL_BLOCK * TCB, int key)
1387 {
1388     bool res = FALSE;
1389
1390     AssertTCB();
1391     if (TCB->csp)
1392         res = TINFO_HAS_KEY(TCB->csp, key) == 0 ? FALSE : TRUE;
1393
1394     return res;
1395 }
1396
1397 NCURSES_EXPORT_VAR (TERM_DRIVER) _nc_TINFO_DRIVER = {
1398     TRUE,
1399         drv_Name,               /* Name */
1400         drv_CanHandle,          /* CanHandle */
1401         drv_init,               /* init */
1402         drv_release,            /* release */
1403         drv_size,               /* size */
1404         drv_sgmode,             /* sgmode */
1405         drv_conattr,            /* conattr */
1406         drv_mvcur,              /* hwcur */
1407         drv_mode,               /* mode */
1408         drv_rescol,             /* rescol */
1409         drv_rescolors,          /* rescolors */
1410         drv_setcolor,           /* color */
1411         drv_dobeepflash,        /* doBeepOrFlash */
1412         drv_initpair,           /* initpair */
1413         drv_initcolor,          /* initcolor */
1414         drv_do_color,           /* docolor */
1415         drv_initmouse,          /* initmouse */
1416         drv_testmouse,          /* testmouse */
1417         drv_setfilter,          /* setfilter */
1418         drv_hwlabel,            /* hwlabel */
1419         drv_hwlabelOnOff,       /* hwlabelOnOff */
1420         drv_doupdate,           /* update */
1421         drv_defaultcolors,      /* defaultcolors */
1422         drv_print,              /* print */
1423         drv_getsize,            /* getsize */
1424         drv_setsize,            /* setsize */
1425         drv_initacs,            /* initacs */
1426         drv_screen_init,        /* scinit */
1427         drv_wrap,               /* scexit */
1428         drv_twait,              /* twait  */
1429         drv_read,               /* read */
1430         drv_nap,                /* nap */
1431         drv_kpad,               /* kpad */
1432         drv_keyok,              /* kyOk */
1433         drv_kyExist,            /* kyExist */
1434         drv_cursorSet           /* cursorSet */
1435 };