1 files changed, 114 insertions, 163 deletions

diff --git a/ncurses/tinfo/lib_options.c b/ncurses/tinfo/lib_options.c
index 654bf940aa1f9..f3b1485bf1113 100644
--- a/ncurses/tinfo/lib_options.c
+++ b/ncurses/tinfo/lib_options.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2008,2009 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2006,2008 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            *
@@ -30,7 +30,6 @@
  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
  *     and: Thomas E. Dickey                        1996-on                 *
- *     and: Juergen Pfeifer                         2009                    *
  ****************************************************************************/
 
 /*
@@ -42,67 +41,53 @@
 
 #include <curses.priv.h>
 
-#ifndef CUR
-#define CUR SP_TERMTYPE
-#endif
+#include <term.h>
+
+MODULE_ID("$Id: lib_options.c,v 1.58 2008/08/16 21:20:48 Werner.Fink Exp $")
 
-MODULE_ID("$Id: lib_options.c,v 1.71 2009/10/24 21:56:15 tom Exp $")
+static int _nc_curs_set(SCREEN *, int);
+static int _nc_meta(SCREEN *, bool);
 
 NCURSES_EXPORT(int)
 idlok(WINDOW *win, bool flag)
 {
-    int res = ERR;
-    T((T_CALLED("idlok(%p,%d)"), (void *) win, flag));
+    T((T_CALLED("idlok(%p,%d)"), win, flag));
 
     if (win) {
-	SCREEN *sp = _nc_screen_of(win);
-	if (sp && IsTermInfo(sp)) {
-	    sp->_nc_sp_idlok =
-		win->_idlok = (flag && (NCURSES_SP_NAME(has_il) (NCURSES_SP_ARG)
-					|| change_scroll_region));
-	    res = OK;
-	}
-    }
-    returnCode(res);
+	_nc_idlok = win->_idlok = (flag && (has_il() || change_scroll_region));
+	returnCode(OK);
+    } else
+	returnCode(ERR);
 }
 
 NCURSES_EXPORT(void)
 idcok(WINDOW *win, bool flag)
 {
-    T((T_CALLED("idcok(%p,%d)"), (void *) win, flag));
+    T((T_CALLED("idcok(%p,%d)"), win, flag));
+
+    if (win)
+	_nc_idcok = win->_idcok = (flag && has_ic());
 
-    if (win) {
-	SCREEN *sp = _nc_screen_of(win);
-	sp->_nc_sp_idcok = win->_idcok = (flag && NCURSES_SP_NAME(has_ic) (NCURSES_SP_ARG));
-    }
     returnVoid;
 }
 
 NCURSES_EXPORT(int)
-NCURSES_SP_NAME(halfdelay) (NCURSES_SP_DCLx int t)
+halfdelay(int t)
 {
-    T((T_CALLED("halfdelay(%p,%d)"), (void *) SP_PARM, t));
+    T((T_CALLED("halfdelay(%d)"), t));
 
-    if (t < 1 || t > 255 || !IsValidTIScreen(SP_PARM))
+    if (t < 1 || t > 255 || SP == 0)
 	returnCode(ERR);
 
-    NCURSES_SP_NAME(cbreak) (NCURSES_SP_ARG);
-    SP_PARM->_cbreak = t + 1;
+    cbreak();
+    SP->_cbreak = t + 1;
     returnCode(OK);
 }
 
-#if NCURSES_SP_FUNCS
-NCURSES_EXPORT(int)
-halfdelay(int t)
-{
-    return NCURSES_SP_NAME(halfdelay) (CURRENT_SCREEN, t);
-}
-#endif
-
 NCURSES_EXPORT(int)
 nodelay(WINDOW *win, bool flag)
 {
-    T((T_CALLED("nodelay(%p,%d)"), (void *) win, flag));
+    T((T_CALLED("nodelay(%p,%d)"), win, flag));
 
     if (win) {
 	if (flag == TRUE)
@@ -117,7 +102,7 @@ nodelay(WINDOW *win, bool flag)
 NCURSES_EXPORT(int)
 notimeout(WINDOW *win, bool f)
 {
-    T((T_CALLED("notimeout(%p,%d)"), (void *) win, f));
+    T((T_CALLED("notimeout(%p,%d)"), win, f));
 
     if (win) {
 	win->_notimeout = f;
@@ -129,7 +114,7 @@ notimeout(WINDOW *win, bool f)
 NCURSES_EXPORT(void)
 wtimeout(WINDOW *win, int delay)
 {
-    T((T_CALLED("wtimeout(%p,%d)"), (void *) win, delay));
+    T((T_CALLED("wtimeout(%p,%d)"), win, delay));
 
     if (win) {
 	win->_delay = delay;
@@ -140,11 +125,11 @@ wtimeout(WINDOW *win, int delay)
 NCURSES_EXPORT(int)
 keypad(WINDOW *win, bool flag)
 {
-    T((T_CALLED("keypad(%p,%d)"), (void *) win, flag));
+    T((T_CALLED("keypad(%p,%d)"), win, flag));
 
     if (win) {
 	win->_use_keypad = flag;
-	returnCode(_nc_keypad(_nc_screen_of(win), flag));
+	returnCode(_nc_keypad(SP, flag));
     } else
 	returnCode(ERR);
 }
@@ -152,106 +137,38 @@ keypad(WINDOW *win, bool flag)
 NCURSES_EXPORT(int)
 meta(WINDOW *win GCC_UNUSED, bool flag)
 {
-    int result = ERR;
-    SCREEN *sp = (win == 0) ? CURRENT_SCREEN : _nc_screen_of(win);
-
-    /* Ok, we stay relaxed and don't signal an error if win is NULL */
-    T((T_CALLED("meta(%p,%d)"), (void *) win, flag));
+    int result;
 
     /* Ok, we stay relaxed and don't signal an error if win is NULL */
-
-    if (sp != 0) {
-	sp->_use_meta = flag;
-#ifdef USE_TERM_DRIVER
-	if (IsTermInfo(sp)) {
-	    if (flag) {
-		NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "meta_on", meta_on);
-	    } else {
-		NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "meta_off", meta_off);
-	    }
-	}
-#else
-	if (flag) {
-	    NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "meta_on", meta_on);
-	} else {
-	    NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx "meta_off", meta_off);
-	}
-#endif
-	result = OK;
-    }
+    T((T_CALLED("meta(%p,%d)"), win, flag));
+    result = _nc_meta(SP, flag);
     returnCode(result);
 }
 
 /* curs_set() moved here to narrow the kernel interface */
 
 NCURSES_EXPORT(int)
-NCURSES_SP_NAME(curs_set) (NCURSES_SP_DCLx int vis)
-{
-    int code = ERR;
-    T((T_CALLED("curs_set(%p,%d)"), (void *) SP_PARM, vis));
-
-    if (SP_PARM != 0 && vis >= 0 && vis <= 2) {
-	int cursor = SP_PARM->_cursor;
-	bool bBuiltIn = !IsTermInfo(SP_PARM);
-	if (vis == cursor) {
-	    code = cursor;
-	} else {
-	    if (!bBuiltIn) {
-		switch (vis) {
-		case 2:
-		    code = NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_ARGx
-							    "cursor_visible",
-							    cursor_visible);
-		    break;
-		case 1:
-		    code = NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_ARGx
-							    "cursor_normal",
-							    cursor_normal);
-		    break;
-		case 0:
-		    code = NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_ARGx
-							    "cursor_invisible",
-							    cursor_invisible);
-		    break;
-		}
-	    } else
-		code = ERR;
-	    if (code != ERR)
-		code = (cursor == -1 ? 1 : cursor);
-	    SP_PARM->_cursor = vis;
-	}
-    }
-    returnCode(code);
-}
-
-#if NCURSES_SP_FUNCS
-NCURSES_EXPORT(int)
 curs_set(int vis)
 {
-    return (NCURSES_SP_NAME(curs_set) (CURRENT_SCREEN, vis));
+    int result;
+
+    T((T_CALLED("curs_set(%d)"), vis));
+    result = _nc_curs_set(SP, vis);
+    returnCode(result);
 }
-#endif
 
 NCURSES_EXPORT(int)
-NCURSES_SP_NAME(typeahead) (NCURSES_SP_DCLx int fd)
+typeahead(int fd)
 {
-    T((T_CALLED("typeahead(%p, %d)"), (void *) SP_PARM, fd));
-    if (IsValidTIScreen(SP_PARM)) {
-	SP_PARM->_checkfd = fd;
+    T((T_CALLED("typeahead(%d)"), fd));
+    if (SP != 0) {
+	SP->_checkfd = fd;
 	returnCode(OK);
     } else {
 	returnCode(ERR);
     }
 }
 
-#if NCURSES_SP_FUNCS
-NCURSES_EXPORT(int)
-typeahead(int fd)
-{
-    return NCURSES_SP_NAME(typeahead) (CURRENT_SCREEN, fd);
-}
-#endif
-
 /*
 **      has_key()
 **
@@ -272,49 +189,42 @@ has_key_internal(int keycode, TRIES * tp)
 		|| has_key_internal(keycode, tp->sibling));
 }
 
-#ifdef USE_TERM_DRIVER
-NCURSES_EXPORT(int)
-TINFO_HAS_KEY(SCREEN *sp, int keycode)
-{
-    return IsValidTIScreen(sp) ?
-	has_key_internal(keycode, sp->_keytry) : 0;
-}
-#else
-NCURSES_EXPORT(int)
-NCURSES_SP_NAME(has_key) (NCURSES_SP_DCLx int keycode)
-{
-    T((T_CALLED("has_key(%p,%d)"), (void *) SP_PARM, keycode));
-    returnCode(SP != 0 ? has_key_internal(keycode, SP_PARM->_keytry) : FALSE);
-}
-
-#if NCURSES_SP_FUNCS
 NCURSES_EXPORT(int)
 has_key(int keycode)
 {
-    return NCURSES_SP_NAME(has_key) (CURRENT_SCREEN, keycode);
+    T((T_CALLED("has_key(%d)"), keycode));
+    returnCode(SP != 0 ? has_key_internal(keycode, SP->_keytry) : FALSE);
 }
-#endif
-#endif
 #endif /* NCURSES_EXT_FUNCS */
 
-NCURSES_EXPORT(int)
-NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_DCLx
-				 const char *name, const char *value)
+/*
+ * Internal entrypoints use SCREEN* parameter to obtain capabilities rather
+ * than cur_term.
+ */
+#undef CUR
+#define CUR (sp->_term)->type.
+
+static int
+_nc_putp(const char *name GCC_UNUSED, const char *value)
 {
-    int rc = NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx name, value);
-    if (rc != ERR) {
-	_nc_flush();
+    int rc = ERR;
+
+    if (value) {
+	TPUTS_TRACE(name);
+	rc = putp(value);
     }
     return rc;
 }
 
-#if 0 && NCURSES_SP_FUNCS
-NCURSES_EXPORT(int)
+static int
 _nc_putp_flush(const char *name, const char *value)
 {
-    return NCURSES_SP_NAME(_nc_putp_flush) (CURRENT_SCREEN, name, value);
+    int rc = _nc_putp(name, value);
+    if (rc != ERR) {
+	_nc_flush();
+    }
+    return rc;
 }
-#endif
 
 /* Turn the keypad on/off
  *
@@ -335,12 +245,12 @@ _nc_keypad(SCREEN *sp, bool flag)
 	 * has wgetch() reading in more than one thread.  putp() and below
 	 * may use SP explicitly.
 	 */
-	if (_nc_use_pthreads && sp != CURRENT_SCREEN) {
+	if (_nc_use_pthreads && sp != SP) {
 	    SCREEN *save_sp;
 
 	    /* cannot use use_screen(), since that is not in tinfo library */
 	    _nc_lock_global(curses);
-	    save_sp = CURRENT_SCREEN;
+	    save_sp = SP;
 	    _nc_set_screen(sp);
 	    rc = _nc_keypad(sp, flag);
 	    _nc_set_screen(save_sp);
@@ -348,19 +258,10 @@ _nc_keypad(SCREEN *sp, bool flag)
 	} else
 #endif
 	{
-#ifdef USE_TERM_DRIVER
-	    rc = CallDriver_1(sp, kpad, flag);
-	    if (rc == OK)
-		sp->_keypad_on = flag;
-#else
 	    if (flag) {
-		(void) NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_ARGx
-							"keypad_xmit",
-							keypad_xmit);
+		(void) _nc_putp_flush("keypad_xmit", keypad_xmit);
 	    } else if (!flag && keypad_local) {
-		(void) NCURSES_SP_NAME(_nc_putp_flush) (NCURSES_SP_ARGx
-							"keypad_local",
-							keypad_local);
+		(void) _nc_putp_flush("keypad_local", keypad_local);
 	    }
 
 	    if (flag && !sp->_tried) {
@@ -369,8 +270,58 @@ _nc_keypad(SCREEN *sp, bool flag)
 	    }
 	    sp->_keypad_on = flag;
 	    rc = OK;
-#endif
 	}
     }
     return (rc);
 }
+
+static int
+_nc_curs_set(SCREEN *sp, int vis)
+{
+    int result = ERR;
+
+    T((T_CALLED("curs_set(%d)"), vis));
+    if (sp != 0 && vis >= 0 && vis <= 2) {
+	int cursor = sp->_cursor;
+
+	if (vis == cursor) {
+	    result = cursor;
+	} else {
+	    switch (vis) {
+	    case 2:
+		result = _nc_putp_flush("cursor_visible", cursor_visible);
+		break;
+	    case 1:
+		result = _nc_putp_flush("cursor_normal", cursor_normal);
+		break;
+	    case 0:
+		result = _nc_putp_flush("cursor_invisible", cursor_invisible);
+		break;
+	    }
+	    if (result != ERR)
+		result = (cursor == -1 ? 1 : cursor);
+	    sp->_cursor = vis;
+	}
+    }
+    returnCode(result);
+}
+
+static int
+_nc_meta(SCREEN *sp, bool flag)
+{
+    int result = ERR;
+
+    /* Ok, we stay relaxed and don't signal an error if win is NULL */
+
+    if (SP != 0) {
+	SP->_use_meta = flag;
+
+	if (flag) {
+	    _nc_putp("meta_on", meta_on);
+	} else {
+	    _nc_putp("meta_off", meta_off);
+	}
+	result = OK;
+    }
+    return result;
+}