ncurses 5.9 - patch 20150404
[ncurses.git] / ncurses / tinfo / tinfo_driver.c
index 990b1773fb44556d9ede965fae62aa4578712f84..a17accd358e543be61110f942c45e97d5f9a60c1 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 2008,2009 Free Software Foundation, Inc.                   *
+ * Copyright (c) 2008-2013,2014 Free Software Foundation, Inc.              *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
 #endif
 #endif
 
-MODULE_ID("$Id: tinfo_driver.c,v 1.2 2009/08/16 14:17:08 tom Exp $")
+#if HAVE_SIZECHANGE
+# if !defined(sun) || !TERMIOS
+#  if HAVE_SYS_IOCTL_H
+#   include <sys/ioctl.h>
+#  endif
+# endif
+#endif
+
+MODULE_ID("$Id: tinfo_driver.c,v 1.39 2014/09/27 21:58:57 tom Exp $")
 
 /*
  * SCO defines TIOCGSIZE and the corresponding struct.  Other systems (SunOS,
@@ -83,87 +91,9 @@ NCURSES_EXPORT_VAR(int) COLOR_PAIRS = 0;
 NCURSES_EXPORT_VAR(int) COLORS = 0;
 #endif
 
-static bool drv_CanHandle(TERMINAL_CONTROL_BLOCK * TCB, const char *tname, int *);
-static void drv_init(TERMINAL_CONTROL_BLOCK *);
-static void drv_release(TERMINAL_CONTROL_BLOCK *);
-static int drv_size(TERMINAL_CONTROL_BLOCK *, int *, int *);
-static int drv_sgmode(TERMINAL_CONTROL_BLOCK * TCB, bool setFlag, TTY * buf);
-static chtype drv_conattr(TERMINAL_CONTROL_BLOCK * TCB);
-static int drv_mvcur(TERMINAL_CONTROL_BLOCK * TCB, int yold, int xold, int
-                    ynew, int xnew);
-static int drv_mode(TERMINAL_CONTROL_BLOCK * TCB, bool progFlag, bool defFlag);
-static bool drv_rescol(TERMINAL_CONTROL_BLOCK * TCB);
-static bool drv_rescolors(TERMINAL_CONTROL_BLOCK * TCB);
-static void drv_setcolor(TERMINAL_CONTROL_BLOCK * TCB, bool fore, int color, int
-                          (*outc) (SCREEN *, int));
-static int drv_dobeepflash(TERMINAL_CONTROL_BLOCK * TCB, bool beepFlag);
-static void drv_initpair(TERMINAL_CONTROL_BLOCK * TCB, short pair, short f, short b);
-static void drv_initcolor(TERMINAL_CONTROL_BLOCK * TCB, short color, short
-                         r, short g, short b);
-static void drv_do_color(TERMINAL_CONTROL_BLOCK * TCB, short old_pair, short
-                        pair, bool reverse,
-                        int (*outc) (SCREEN *, int));
-static void drv_initmouse(TERMINAL_CONTROL_BLOCK * TCB);
-static void drv_setfilter(TERMINAL_CONTROL_BLOCK * TCB);
-static void drv_hwlabel(TERMINAL_CONTROL_BLOCK * TCB, int labnum, char *text);
-static void drv_hwlabelOnOff(TERMINAL_CONTROL_BLOCK * TCB, bool OnFlag);
-static int drv_doupdate(TERMINAL_CONTROL_BLOCK * TCB);
-static int drv_defaultcolors(TERMINAL_CONTROL_BLOCK * TCB, int fg, int bg);
-static int drv_print(TERMINAL_CONTROL_BLOCK * TCB, char *data, int len);
-static int drv_getsize(TERMINAL_CONTROL_BLOCK *, int *, int *);
-static int drv_setsize(TERMINAL_CONTROL_BLOCK * TCB, int l, int c);
-static void drv_initacs(TERMINAL_CONTROL_BLOCK * TCB, chtype *, chtype *);
-static void drv_wrap(SCREEN *);
-static void drv_screen_init(SCREEN *);
-static int drv_twait(TERMINAL_CONTROL_BLOCK *, int, int, int
-                    *EVENTLIST_2nd(_nc_eventlist
-                                   *));
-static int drv_read(TERMINAL_CONTROL_BLOCK * TCB, int *buf);
-static int drv_nap(TERMINAL_CONTROL_BLOCK * TCB GCC_UNUSED, int ms);
-static int drv_kpad(TERMINAL_CONTROL_BLOCK * TCB, bool);
-static int drv_keyok(TERMINAL_CONTROL_BLOCK * TCB, int, bool);
-static bool drv_kyExist(TERMINAL_CONTROL_BLOCK * TCB, int);
-
-NCURSES_EXPORT_VAR (TERM_DRIVER) _nc_TINFO_DRIVER = {
-    TRUE,
-       drv_CanHandle,          /* CanHandle */
-       drv_init,               /* init */
-       drv_release,            /* release */
-       drv_size,               /* size */
-       drv_sgmode,             /* sgmode */
-       drv_conattr,            /* conattr */
-       drv_mvcur,              /* hwcur */
-       drv_mode,               /* mode */
-       drv_rescol,             /* rescol */
-       drv_rescolors,          /* rescolors */
-       drv_setcolor,           /* color */
-       drv_dobeepflash,        /* doBeepOrFlash */
-       drv_initpair,           /* initpair */
-       drv_initcolor,          /* initcolor */
-       drv_do_color,           /* docolor */
-       drv_initmouse,          /* initmouse */
-       drv_setfilter,          /* setfilter */
-       drv_hwlabel,            /* hwlabel */
-       drv_hwlabelOnOff,       /* hwlabelOnOff */
-       drv_doupdate,           /* update */
-       drv_defaultcolors,      /* defaultcolors */
-       drv_print,              /* print */
-       drv_getsize,            /* getsize */
-       drv_setsize,            /* setsize */
-       drv_initacs,            /* initacs */
-       drv_screen_init,        /* scinit */
-       drv_wrap,               /* scexit */
-       drv_twait,              /* twait  */
-       drv_read,               /* read */
-       drv_nap,                /* nap */
-       drv_kpad,               /* kpad */
-       drv_keyok,              /* kyOk */
-       drv_kyExist             /* kyExist */
-};
-
 #define TCBMAGIC NCDRV_MAGIC(NCDRV_TINFO)
 #define AssertTCB() assert(TCB!=0 && TCB->magic==TCBMAGIC)
-#define SetSP() assert(TCB->csp!=0); sp = TCB->csp
+#define SetSP() assert(TCB->csp!=0); sp = TCB->csp; (void) sp
 
 /*
  * This routine needs to do all the work to make curscr look
@@ -176,82 +106,12 @@ drv_doupdate(TERMINAL_CONTROL_BLOCK * TCB)
     return TINFO_DOUPDATE(TCB->csp);
 }
 
-/*
-**     do_prototype()
-**
-**     Take the real command character out of the CC environment variable
-**     and substitute it in for the prototype given in 'command_character'.
-*/
-static void
-do_prototype(TERMINAL * termp)
-{
-    unsigned i;
-    char CC;
-    char proto;
-    char *tmp;
-    TERMINAL_CONTROL_BLOCK *TCB = (TERMINAL_CONTROL_BLOCK *) termp;
-
-    if ((tmp = getenv("CC")) != 0) {
-       if ((CC = *tmp) != 0) {
-           proto = *command_character;
-
-           for_each_string(i, &(termp->type)) {
-               for (tmp = termp->type.Strings[i]; *tmp; tmp++) {
-                   if (*tmp == proto)
-                       *tmp = CC;
-               }
-           }
-       }
-    }
-}
-
-#define ret_error(code, fmt, arg)      if (errret) {\
-                                           *errret = code;\
-                                           return(FALSE); \
-                                       } else {\
-                                           fprintf(stderr, fmt, arg);\
-                                           exit(EXIT_FAILURE);\
-                                       }
-
-#define ret_error0(code, msg)          if (errret) {\
-                                           *errret = code;\
-                                           return(FALSE);\
-                                       } else {\
-                                           fprintf(stderr, msg);\
-                                           exit(EXIT_FAILURE);\
-                                       }
-
-#if USE_DATABASE || USE_TERMCAP
-/*
- * Return 1 if entry found, 0 if not found, -1 if database not accessible,
- * just like tgetent().
- */
-static int
-grab_entry(const char *const tn, TERMTYPE *const tp)
+static const char *
+drv_Name(TERMINAL_CONTROL_BLOCK * TCB)
 {
-    char filename[PATH_MAX];
-    int status = _nc_read_entry(tn, filename, tp);
-
-    /*
-     * If we have an entry, force all of the cancelled strings to null
-     * pointers so we don't have to test them in the rest of the library.
-     * (The terminfo compiler bypasses this logic, since it must know if
-     * a string is cancelled, for merging entries).
-     */
-    if (status == TGETENT_YES) {
-       unsigned n;
-       for_each_boolean(n, tp) {
-           if (!VALID_BOOLEAN(tp->Booleans[n]))
-               tp->Booleans[n] = FALSE;
-       }
-       for_each_string(n, tp) {
-           if (tp->Strings[n] == CANCELLED_STRING)
-               tp->Strings[n] = ABSENT_STRING;
-       }
-    }
-    return (status);
+    (void) TCB;
+    return "tinfo";
 }
-#endif
 
 static bool
 drv_CanHandle(TERMINAL_CONTROL_BLOCK * TCB, const char *tname, int *errret)
@@ -261,13 +121,15 @@ drv_CanHandle(TERMINAL_CONTROL_BLOCK * TCB, const char *tname, int *errret)
     TERMINAL *termp;
     SCREEN *sp;
 
+    T((T_CALLED("tinfo::drv_CanHandle(%p)"), TCB));
+
     assert(TCB != 0 && tname != 0);
     termp = (TERMINAL *) TCB;
     sp = TCB->csp;
     TCB->magic = TCBMAGIC;
 
-#if (USE_DATABASE || USE_TERMCAP)
-    status = grab_entry(tname, &termp->type);
+#if (NCURSES_USE_DATABASE || NCURSES_USE_TERMCAP)
+    status = _nc_setup_tinfo(tname, &termp->type);
 #else
     status = TGETENT_NO;
 #endif
@@ -287,30 +149,40 @@ drv_CanHandle(TERMINAL_CONTROL_BLOCK * TCB, const char *tname, int *errret)
        if (status == TGETENT_ERR) {
            ret_error0(status, "terminals database is inaccessible\n");
        } else if (status == TGETENT_NO) {
-           ret_error(status, "'%s': unknown terminal type.\n", tname);
+           ret_error1(status, "unknown terminal type.\n", tname);
        }
     }
     result = TRUE;
 #if !USE_REENTRANT
-    strncpy(ttytype, termp->type.term_names, NAMESIZE - 1);
+    strncpy(ttytype, termp->type.term_names, (size_t) NAMESIZE - 1);
     ttytype[NAMESIZE - 1] = '\0';
 #endif
 
-    if (command_character && getenv("CC"))
-       do_prototype(termp);
+    if (command_character)
+       _nc_tinfo_cmdch(termp, *command_character);
 
     if (generic_type) {
-       ret_error(TGETENT_NO, "'%s': I need something more specific.\n", tname);
+       /*
+        * BSD 4.3's termcap contains mis-typed "gn" for wy99.  Do a sanity
+        * check before giving up.
+        */
+       if ((VALID_STRING(cursor_address)
+            || (VALID_STRING(cursor_down) && VALID_STRING(cursor_home)))
+           && VALID_STRING(clear_screen)) {
+           ret_error1(TGETENT_YES, "terminal is not really generic.\n", tname);
+       } else {
+           ret_error1(TGETENT_NO, "I need something more specific.\n", tname);
+       }
     }
     if (hard_copy) {
-       ret_error(TGETENT_YES, "'%s': I can't handle hardcopy terminals.\n", tname);
+       ret_error1(TGETENT_YES, "I can't handle hardcopy terminals.\n", tname);
     }
 
-    return result;
+    returnBool(result);
 }
 
 static int
-drv_dobeepflash(TERMINAL_CONTROL_BLOCK * TCB, bool beepFlag)
+drv_dobeepflash(TERMINAL_CONTROL_BLOCK * TCB, int beepFlag)
 {
     SCREEN *sp;
     int res = ERR;
@@ -321,22 +193,18 @@ drv_dobeepflash(TERMINAL_CONTROL_BLOCK * TCB, bool beepFlag)
     /* FIXME: should make sure that we are not in altchar mode */
     if (beepFlag) {
        if (bell) {
-           res = NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "bell", bell);
+           res = NCURSES_PUTP2("bell", bell);
            NCURSES_SP_NAME(_nc_flush) (sp);
        } else if (flash_screen) {
-           res = NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                            "flash_screen",
-                                            flash_screen);
+           res = NCURSES_PUTP2("flash_screen", flash_screen);
            NCURSES_SP_NAME(_nc_flush) (sp);
        }
     } else {
        if (flash_screen) {
-           res = NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                            "flash_screen",
-                                            flash_screen);
+           res = NCURSES_PUTP2("flash_screen", flash_screen);
            NCURSES_SP_NAME(_nc_flush) (sp);
        } else if (bell) {
-           res = NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "bell", bell);
+           res = NCURSES_PUTP2("bell", bell);
            NCURSES_SP_NAME(_nc_flush) (sp);
        }
     }
@@ -407,8 +275,10 @@ drv_defaultcolors(TERMINAL_CONTROL_BLOCK * TCB, int fg, int bg)
 }
 
 static void
-drv_setcolor(TERMINAL_CONTROL_BLOCK * TCB, bool fore, int color, int (*outc)
-              (SCREEN *, int))
+drv_setcolor(TERMINAL_CONTROL_BLOCK * TCB,
+            int fore,
+            int color,
+            NCURSES_SP_OUTC outc)
 {
     SCREEN *sp;
 
@@ -450,7 +320,7 @@ drv_rescol(TERMINAL_CONTROL_BLOCK * TCB)
     SetSP();
 
     if (orig_pair != 0) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "orig_pair", orig_pair);
+       NCURSES_PUTP2("orig_pair", orig_pair);
        result = TRUE;
     }
     return result;
@@ -466,7 +336,7 @@ drv_rescolors(TERMINAL_CONTROL_BLOCK * TCB)
     SetSP();
 
     if (orig_colors != 0) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "orig_colors", orig_colors);
+       NCURSES_PUTP2("orig_colors", orig_colors);
        result = TRUE;
     }
     return result;
@@ -477,73 +347,92 @@ drv_size(TERMINAL_CONTROL_BLOCK * TCB, int *linep, int *colp)
 {
     SCREEN *sp;
     bool useEnv = TRUE;
+    bool useTioctl = TRUE;
 
     AssertTCB();
     sp = TCB->csp;             /* can be null here */
 
     if (sp) {
        useEnv = sp->_use_env;
-    } else
+       useTioctl = sp->_use_tioctl;
+    } else {
        useEnv = _nc_prescreen.use_env;
+       useTioctl = _nc_prescreen.use_tioctl;
+    }
 
     /* figure out the size of the screen */
     T(("screen size: terminfo lines = %d columns = %d", lines, columns));
 
-    if (!useEnv) {
-       *linep = (int) lines;
-       *colp = (int) columns;
-    } else {                   /* usually want to query LINES and COLUMNS from environment */
-       int value;
-
-       *linep = *colp = 0;
+    *linep = (int) lines;
+    *colp = (int) columns;
 
-       /* first, look for environment variables */
-       if ((value = _nc_getenv_num("LINES")) > 0) {
-           *linep = value;
-       }
-       if ((value = _nc_getenv_num("COLUMNS")) > 0) {
-           *colp = value;
-       }
-       T(("screen size: environment LINES = %d COLUMNS = %d", *linep, *colp));
+    if (useEnv || useTioctl) {
+       int value;
 
 #ifdef __EMX__
-       if (*linep <= 0 || *colp <= 0) {
+       {
            int screendata[2];
            _scrsize(screendata);
            *colp = screendata[0];
-           *linep = screendata[1];
+           *linep = ((sp != 0 && sp->_filtered)
+                     ? 1
+                     : screendata[1]);
            T(("EMX screen size: environment LINES = %d COLUMNS = %d",
               *linep, *colp));
        }
 #endif
 #if HAVE_SIZECHANGE
-       /* if that didn't work, maybe we can try asking the OS */
-       if (*linep <= 0 || *colp <= 0) {
+       /* try asking the OS */
+       {
            TERMINAL *termp = (TERMINAL *) TCB;
-           if (isatty(termp->Filedes)) {
+           if (NC_ISATTY(termp->Filedes)) {
                STRUCT_WINSIZE size;
 
                errno = 0;
                do {
-                   if (ioctl(termp->Filedes, IOCTL_WINSIZE, &size) < 0
-                       && errno != EINTR)
-                       goto failure;
+                   if (ioctl(termp->Filedes, IOCTL_WINSIZE, &size) >= 0) {
+                       *linep = ((sp != 0 && sp->_filtered)
+                                 ? 1
+                                 : WINSIZE_ROWS(size));
+                       *colp = WINSIZE_COLS(size);
+                       T(("SYS screen size: environment LINES = %d COLUMNS = %d",
+                          *linep, *colp));
+                       break;
+                   }
                } while
                    (errno == EINTR);
+           }
+       }
+#endif /* HAVE_SIZECHANGE */
 
+       if (useEnv) {
+           if (useTioctl) {
                /*
-                * Solaris lets users override either dimension with an
-                * environment variable.
+                * If environment variables are used, update them.
                 */
-               if (*linep <= 0)
-                   *linep = (sp != 0 && sp->_filtered) ? 1 : WINSIZE_ROWS(size);
-               if (*colp <= 0)
-                   *colp = WINSIZE_COLS(size);
+               if ((sp == 0 || !sp->_filtered) && _nc_getenv_num("LINES") > 0) {
+                   _nc_setenv_num("LINES", *linep);
+               }
+               if (_nc_getenv_num("COLUMNS") > 0) {
+                   _nc_setenv_num("COLUMNS", *colp);
+               }
+           }
+
+           /*
+            * Finally, look for environment variables.
+            *
+            * Solaris lets users override either dimension with an environment
+            * variable.
+            */
+           if ((value = _nc_getenv_num("LINES")) > 0) {
+               *linep = value;
+               T(("screen size: environment LINES = %d", *linep));
+           }
+           if ((value = _nc_getenv_num("COLUMNS")) > 0) {
+               *colp = value;
+               T(("screen size: environment COLUMNS = %d", *colp));
            }
-           /* FALLTHRU */
-         failure:;
        }
-#endif /* HAVE_SIZECHANGE */
 
        /* if we can't get dynamic info about the size, use static */
        if (*linep <= 0) {
@@ -587,13 +476,47 @@ static int
 drv_setsize(TERMINAL_CONTROL_BLOCK * TCB, int l, int c)
 {
     AssertTCB();
-    lines = l;
-    columns = c;
+    lines = (short) l;
+    columns = (short) c;
     return OK;
 }
 
 static int
-drv_mode(TERMINAL_CONTROL_BLOCK * TCB, bool progFlag, bool defFlag)
+drv_sgmode(TERMINAL_CONTROL_BLOCK * TCB, int setFlag, TTY * buf)
+{
+    SCREEN *sp = TCB->csp;
+    TERMINAL *_term = (TERMINAL *) TCB;
+    int result = OK;
+
+    AssertTCB();
+    if (setFlag) {
+       for (;;) {
+           if (SET_TTY(_term->Filedes, buf) != 0) {
+               if (errno == EINTR)
+                   continue;
+               if (errno == ENOTTY) {
+                   if (sp)
+                       sp->_notty = TRUE;
+               }
+               result = ERR;
+           }
+           break;
+       }
+    } else {
+       for (;;) {
+           if (GET_TTY(_term->Filedes, buf) != 0) {
+               if (errno == EINTR)
+                   continue;
+               result = ERR;
+           }
+           break;
+       }
+    }
+    return result;
+}
+
+static int
+drv_mode(TERMINAL_CONTROL_BLOCK * TCB, int progFlag, int defFlag)
 {
     SCREEN *sp;
     TERMINAL *_term = (TERMINAL *) TCB;
@@ -611,9 +534,9 @@ drv_mode(TERMINAL_CONTROL_BLOCK * TCB, bool progFlag, bool defFlag)
             */
            if ((drv_sgmode(TCB, FALSE, &(_term->Nttyb)) == OK)) {
 #ifdef TERMIOS
-               _term->Nttyb.c_oflag &= ~OFLAGS_TABS;
+               _term->Nttyb.c_oflag &= (unsigned) ~OFLAGS_TABS;
 #else
-               _term->Nttyb.sg_flags &= ~XTABS;
+               _term->Nttyb.sg_flags &= (unsigned) ~XTABS;
 #endif
                code = OK;
            }
@@ -623,7 +546,6 @@ drv_mode(TERMINAL_CONTROL_BLOCK * TCB, bool progFlag, bool defFlag)
                if (sp) {
                    if (sp->_keypad_on)
                        _nc_keypad(sp, TRUE);
-                   NC_BUFFERED(sp, TRUE);
                }
                code = OK;
            }
@@ -649,7 +571,6 @@ drv_mode(TERMINAL_CONTROL_BLOCK * TCB, bool progFlag, bool defFlag)
            if (sp) {
                _nc_keypad(sp, FALSE);
                NCURSES_SP_NAME(_nc_flush) (sp);
-               NC_BUFFERED(sp, FALSE);
            }
            code = drv_sgmode(TCB, TRUE, &(_term->Ottyb));
        }
@@ -674,7 +595,7 @@ drv_release(TERMINAL_CONTROL_BLOCK * TCB GCC_UNUSED)
 
 #  define SGR0_TEST(mode) (mode != 0) && (exit_attribute_mode == 0 || strcmp(mode, exit_attribute_mode))
 
-void
+static void
 drv_screen_init(SCREEN *sp)
 {
     TERMINAL_CONTROL_BLOCK *TCB = TCBOf(sp);
@@ -716,15 +637,13 @@ drv_screen_init(SCREEN *sp)
 static void
 drv_init(TERMINAL_CONTROL_BLOCK * TCB)
 {
-    SCREEN *sp;
     TERMINAL *trm;
 
     AssertTCB();
 
     trm = (TERMINAL *) TCB;
-    sp = TCB->csp;
 
-    TCB->info.initcolor = initialize_color;
+    TCB->info.initcolor = VALID_STRING(initialize_color);
     TCB->info.canchange = can_change;
     TCB->info.hascolor = ((VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs)
                           && (((set_foreground != NULL)
@@ -752,8 +671,8 @@ drv_init(TERMINAL_CONTROL_BLOCK * TCB)
      * _nc_setupscreen().  Do it now anyway, so we can initialize the
      * baudrate.
      */
-    if (isatty(trm->Filedes)) {
-       TCB->drv->mode(TCB, TRUE, TRUE);
+    if (NC_ISATTY(trm->Filedes)) {
+       TCB->drv->td_mode(TCB, TRUE, TRUE);
     }
 }
 
@@ -761,7 +680,7 @@ drv_init(TERMINAL_CONTROL_BLOCK * TCB)
 #define InPalette(n)   ((n) >= 0 && (n) < MAX_PALETTE)
 
 static void
-drv_initpair(TERMINAL_CONTROL_BLOCK * TCB, short pair, short f, short b)
+drv_initpair(TERMINAL_CONTROL_BLOCK * TCB, int pair, int f, int b)
 {
     SCREEN *sp;
 
@@ -777,12 +696,11 @@ drv_initpair(TERMINAL_CONTROL_BLOCK * TCB, short pair, short f, short b)
            tp[f].red, tp[f].green, tp[f].blue,
            tp[b].red, tp[b].green, tp[b].blue));
 
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                  "initialize_pair",
-                                  TPARM_7(initialize_pair,
-                                          pair,
-                                          tp[f].red, tp[f].green, tp[f].blue,
-                                          tp[b].red, tp[b].green, tp[b].blue));
+       NCURSES_PUTP2("initialize_pair",
+                     TPARM_7(initialize_pair,
+                             pair,
+                             tp[f].red, tp[f].green, tp[f].blue,
+                             tp[b].red, tp[b].green, tp[b].blue));
     }
 }
 
@@ -808,23 +726,22 @@ default_bg(SCREEN *sp)
 
 static void
 drv_initcolor(TERMINAL_CONTROL_BLOCK * TCB,
-             short color, short r, short g, short b)
+             int color, int r, int g, int b)
 {
     SCREEN *sp = TCB->csp;
 
     AssertTCB();
     if (initialize_color != NULL) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                  "initialize_color",
-                                  TPARM_4(initialize_color, color, r, g, b));
+       NCURSES_PUTP2("initialize_color",
+                     TPARM_4(initialize_color, color, r, g, b));
     }
 }
 
 static void
 drv_do_color(TERMINAL_CONTROL_BLOCK * TCB,
-            short old_pair,
-            short pair,
-            bool reverse,
+            int old_pair,
+            int pair,
+            int reverse,
             NCURSES_SP_OUTC outc)
 {
     SCREEN *sp = TCB->csp;
@@ -855,7 +772,7 @@ drv_do_color(TERMINAL_CONTROL_BLOCK * TCB,
     if (old_pair >= 0
        && sp != 0
        && NCURSES_SP_NAME(pair_content) (NCURSES_SP_ARGx
-                                         old_pair,
+                                         (short) old_pair,
                                          &old_fg,
                                          &old_bg) !=ERR) {
        if ((isDefaultColor(fg) && !isDefaultColor(old_fg))
@@ -886,9 +803,9 @@ drv_do_color(TERMINAL_CONTROL_BLOCK * TCB,
 
 #if NCURSES_EXT_FUNCS
     if (isDefaultColor(fg))
-       fg = default_fg(sp);
+       fg = (NCURSES_COLOR_T) default_fg(sp);
     if (isDefaultColor(bg))
-       bg = default_bg(sp);
+       bg = (NCURSES_COLOR_T) default_bg(sp);
 #endif
 
     if (reverse) {
@@ -940,12 +857,47 @@ drv_initmouse(TERMINAL_CONTROL_BLOCK * TCB)
     }
 }
 
+static int
+drv_testmouse(TERMINAL_CONTROL_BLOCK * TCB,
+             int delay
+             EVENTLIST_2nd(_nc_eventlist * evl))
+{
+    int rc = 0;
+    SCREEN *sp;
+
+    AssertTCB();
+    SetSP();
+
+#if USE_SYSMOUSE
+    if ((sp->_mouse_type == M_SYSMOUSE)
+       && (sp->_sysmouse_head < sp->_sysmouse_tail)) {
+       rc = TW_MOUSE;
+    } else
+#endif
+    {
+       rc = TCBOf(sp)->drv->td_twait(TCBOf(sp),
+                                     TWAIT_MASK,
+                                     delay,
+                                     (int *) 0
+                                     EVENTLIST_2nd(evl));
+#if USE_SYSMOUSE
+       if ((sp->_mouse_type == M_SYSMOUSE)
+           && (sp->_sysmouse_head < sp->_sysmouse_tail)
+           && (rc == 0)
+           && (errno == EINTR)) {
+           rc |= TW_MOUSE;
+       }
+#endif
+    }
+    return rc;
+}
+
 static int
 drv_mvcur(TERMINAL_CONTROL_BLOCK * TCB, int yold, int xold, int ynew, int xnew)
 {
     SCREEN *sp = TCB->csp;
     AssertTCB();
-    return TINFO_MVCUR(sp, yold, xold, ynew, xnew);
+    return NCURSES_SP_NAME(_nc_mvcur) (sp, yold, xold, ynew, xnew);
 }
 
 static void
@@ -955,22 +907,21 @@ drv_hwlabel(TERMINAL_CONTROL_BLOCK * TCB, int labnum, char *text)
 
     AssertTCB();
     if (labnum > 0 && labnum <= num_labels) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                  "plab_norm",
-                                  TPARM_2(plab_norm, labnum, text));
+       NCURSES_PUTP2("plab_norm",
+                     TPARM_2(plab_norm, labnum, text));
     }
 }
 
 static void
-drv_hwlabelOnOff(TERMINAL_CONTROL_BLOCK * TCB, bool OnFlag)
+drv_hwlabelOnOff(TERMINAL_CONTROL_BLOCK * TCB, int OnFlag)
 {
     SCREEN *sp = TCB->csp;
 
     AssertTCB();
     if (OnFlag) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "label_on", label_on);
+       NCURSES_PUTP2("label_on", label_on);
     } else {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "label_off", label_off);
+       NCURSES_PUTP2("label_off", label_off);
     }
 }
 
@@ -1011,6 +962,11 @@ drv_conattr(TERMINAL_CONTROL_BLOCK * TCB)
     if (sp && sp->_coloron)
        attrs |= A_COLOR;
 
+#if USE_ITALIC
+    if (enter_italics_mode)
+       attrs |= A_ITALIC;
+#endif
+
     return (attrs);
 }
 
@@ -1027,40 +983,6 @@ drv_setfilter(TERMINAL_CONTROL_BLOCK * TCB)
     cursor_home = carriage_return;
 }
 
-static int
-drv_sgmode(TERMINAL_CONTROL_BLOCK * TCB, bool setFlag, TTY * buf)
-{
-    SCREEN *sp = TCB->csp;
-    TERMINAL *_term = (TERMINAL *) TCB;
-    int result = OK;
-
-    AssertTCB();
-    if (setFlag) {
-       for (;;) {
-           if (SET_TTY(_term->Filedes, buf) != 0) {
-               if (errno == EINTR)
-                   continue;
-               if (errno == ENOTTY) {
-                   if (sp)
-                       sp->_notty = TRUE;
-               }
-               result = ERR;
-           }
-           break;
-       }
-    } else {
-       for (;;) {
-           if (GET_TTY(_term->Filedes, buf) != 0) {
-               if (errno == EINTR)
-                   continue;
-               result = ERR;
-           }
-           break;
-       }
-    }
-    return result;
-}
-
 static void
 drv_initacs(TERMINAL_CONTROL_BLOCK * TCB, chtype *real_map, chtype *fake_map)
 {
@@ -1069,7 +991,7 @@ drv_initacs(TERMINAL_CONTROL_BLOCK * TCB, chtype *real_map, chtype *fake_map)
     AssertTCB();
     assert(sp != 0);
     if (ena_acs != NULL) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "ena_acs", ena_acs);
+       NCURSES_PUTP2("ena_acs", ena_acs);
     }
 #if NCURSES_EXT_FUNCS
     /*
@@ -1088,7 +1010,7 @@ drv_initacs(TERMINAL_CONTROL_BLOCK * TCB, chtype *real_map, chtype *fake_map)
        size_t i;
        for (i = 1; i < ACS_LEN; ++i) {
            if (real_map[i] == 0) {
-               real_map[i] = i;
+               real_map[i] = (chtype) i;
                if (real_map != fake_map) {
                    if (sp != 0)
                        sp->_screen_acs_map[i] = TRUE;
@@ -1171,16 +1093,7 @@ _nc_cookie_init(SCREEN *sp)
 
     if (magic_cookie_glitch > 0) {     /* tvi, wyse */
 
-       sp->_xmc_triggers = sp->_ok_attributes & (
-                                                    A_STANDOUT |
-                                                    A_UNDERLINE |
-                                                    A_REVERSE |
-                                                    A_BLINK |
-                                                    A_DIM |
-                                                    A_BOLD |
-                                                    A_INVIS |
-                                                    A_PROTECT
-           );
+       sp->_xmc_triggers = sp->_ok_attributes & XMC_CONFLICT;
 #if 0
        /*
         * We "should" treat colors as an attribute.  The wyse350 (and its
@@ -1269,7 +1182,14 @@ drv_read(TERMINAL_CONTROL_BLOCK * TCB, int *buf)
     assert(buf);
     SetSP();
 
-    n = read(sp->_ifd, &c2, 1);
+# if USE_PTHREADS_EINTR
+    if ((pthread_self) && (pthread_kill) && (pthread_equal))
+       _nc_globals.read_thread = pthread_self();
+# endif
+    n = read(sp->_ifd, &c2, (size_t) 1);
+#if USE_PTHREADS_EINTR
+    _nc_globals.read_thread = 0;
+#endif
     *buf = (int) c2;
     return n;
 }
@@ -1299,7 +1219,7 @@ __nc_putp(SCREEN *sp, const char *name GCC_UNUSED, const char *value)
     int rc = ERR;
 
     if (value) {
-       rc = NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx name, value);
+       rc = NCURSES_PUTP2(name, value);
     }
     return rc;
 }
@@ -1315,7 +1235,7 @@ __nc_putp_flush(SCREEN *sp, const char *name, const char *value)
 }
 
 static int
-drv_kpad(TERMINAL_CONTROL_BLOCK * TCB, bool flag)
+drv_kpad(TERMINAL_CONTROL_BLOCK * TCB, int flag)
 {
     int ret = ERR;
     SCREEN *sp;
@@ -1341,7 +1261,7 @@ drv_kpad(TERMINAL_CONTROL_BLOCK * TCB, bool flag)
 }
 
 static int
-drv_keyok(TERMINAL_CONTROL_BLOCK * TCB, int c, bool flag)
+drv_keyok(TERMINAL_CONTROL_BLOCK * TCB, int c, int flag)
 {
     SCREEN *sp;
     int code = ERR;
@@ -1354,7 +1274,8 @@ drv_keyok(TERMINAL_CONTROL_BLOCK * TCB, int c, bool flag)
     if (c >= 0) {
        unsigned ch = (unsigned) c;
        if (flag) {
-           while ((s = _nc_expand_try(sp->_key_ok, ch, &count, 0)) != 0
+           while ((s = _nc_expand_try(sp->_key_ok,
+                                      ch, &count, (size_t) 0)) != 0
                   && _nc_remove_key(&(sp->_key_ok), ch)) {
                code = _nc_add_to_try(&(sp->_keytry), s, ch);
                free(s);
@@ -1363,7 +1284,8 @@ drv_keyok(TERMINAL_CONTROL_BLOCK * TCB, int c, bool flag)
                    break;
            }
        } else {
-           while ((s = _nc_expand_try(sp->_keytry, ch, &count, 0)) != 0
+           while ((s = _nc_expand_try(sp->_keytry,
+                                      ch, &count, (size_t) 0)) != 0
                   && _nc_remove_key(&(sp->_keytry), ch)) {
                code = _nc_add_to_try(&(sp->_key_ok), s, ch);
                free(s);
@@ -1376,6 +1298,35 @@ drv_keyok(TERMINAL_CONTROL_BLOCK * TCB, int c, bool flag)
     return (code);
 }
 
+static int
+drv_cursorSet(TERMINAL_CONTROL_BLOCK * TCB, int vis)
+{
+    SCREEN *sp;
+    int code = ERR;
+
+    AssertTCB();
+    SetSP();
+
+    T((T_CALLED("tinfo:drv_cursorSet(%p,%d)"), (void *) SP_PARM, vis));
+
+    if (SP_PARM != 0 && IsTermInfo(SP_PARM)) {
+       switch (vis) {
+       case 2:
+           code = NCURSES_PUTP2_FLUSH("cursor_visible", cursor_visible);
+           break;
+       case 1:
+           code = NCURSES_PUTP2_FLUSH("cursor_normal", cursor_normal);
+           break;
+       case 0:
+           code = NCURSES_PUTP2_FLUSH("cursor_invisible", cursor_invisible);
+           break;
+       }
+    } else {
+       code = ERR;
+    }
+    returnCode(code);
+}
+
 static bool
 drv_kyExist(TERMINAL_CONTROL_BLOCK * TCB, int key)
 {
@@ -1387,3 +1338,43 @@ drv_kyExist(TERMINAL_CONTROL_BLOCK * TCB, int key)
 
     return res;
 }
+
+NCURSES_EXPORT_VAR (TERM_DRIVER) _nc_TINFO_DRIVER = {
+    TRUE,
+       drv_Name,               /* Name */
+       drv_CanHandle,          /* CanHandle */
+       drv_init,               /* init */
+       drv_release,            /* release */
+       drv_size,               /* size */
+       drv_sgmode,             /* sgmode */
+       drv_conattr,            /* conattr */
+       drv_mvcur,              /* hwcur */
+       drv_mode,               /* mode */
+       drv_rescol,             /* rescol */
+       drv_rescolors,          /* rescolors */
+       drv_setcolor,           /* color */
+       drv_dobeepflash,        /* doBeepOrFlash */
+       drv_initpair,           /* initpair */
+       drv_initcolor,          /* initcolor */
+       drv_do_color,           /* docolor */
+       drv_initmouse,          /* initmouse */
+       drv_testmouse,          /* testmouse */
+       drv_setfilter,          /* setfilter */
+       drv_hwlabel,            /* hwlabel */
+       drv_hwlabelOnOff,       /* hwlabelOnOff */
+       drv_doupdate,           /* update */
+       drv_defaultcolors,      /* defaultcolors */
+       drv_print,              /* print */
+       drv_getsize,            /* getsize */
+       drv_setsize,            /* setsize */
+       drv_initacs,            /* initacs */
+       drv_screen_init,        /* scinit */
+       drv_wrap,               /* scexit */
+       drv_twait,              /* twait  */
+       drv_read,               /* read */
+       drv_nap,                /* nap */
+       drv_kpad,               /* kpad */
+       drv_keyok,              /* kyOk */
+       drv_kyExist,            /* kyExist */
+       drv_cursorSet           /* cursorSet */
+};